php crud api
v2.14.29
Script PHP de archivo único que agrega una API REST a una base de datos MySQL/MariaDB, PostgreSQL, SQL Server o SQLite.
Cómo: Cargue " api.php " a su servidor web, configúrelo para conectarse a su base de datos, tenga una API REST instantánea con todas las funciones.
NB: esta es la implementación de referencia de TreeQL en PHP.
PHP 7.2 o superior con controladores PDO habilitados para uno de estos sistemas de bases de datos:
MySQL 5.7 / MariaDB 10.0 o superior para funciones espaciales en MySQL
PostgreSQL 9.5 o superior con PostGIS 2.2 o superior para funciones espaciales
SQL Server 2017 o superior (2019 también es compatible con Linux)
SQLite 3.16 o superior (NO se admiten funciones espaciales)
Descargue el archivo " api.php " de la última versión:
https://github.com/mevdschee/php-crud-api/releases/latest o directamente desde:
https://raw.githubusercontent.com/mevdschee/php-crud-api/main/api.php
¡Esta es una aplicación de un solo archivo! ¡Sube " api.php " a algún lugar y disfruta!
Para el desarrollo local, puede ejecutar el servidor web integrado de PHP:
php -S localhost:8080
Pruebe el script abriendo la siguiente URL:
http://localhost:8080/api.php/records/posts/1
No olvide modificar la configuración al final del archivo.
Alternativamente, puede integrar este proyecto en el marco web de su elección, consulte:
API REST automática para Laravel
API REST automática para Symfony 4
API REST automática para SlimPHP 4
En estas integraciones, Composer se utiliza para cargar este proyecto como una dependencia.
Para las personas que no usan Composer, se proporciona el archivo " api.include.php ". Este archivo contiene todo, desde " api.php ", excepto la configuración de " src/index.php " y puede ser utilizado por la función "incluir" de PHP.
Edite las siguientes líneas en la parte inferior del archivo " api.php ":
$config = new Config([ 'username' => 'xxx', 'password' => 'xxx', 'database' => 'xxx', ]);
Estas son todas las opciones de configuración y su valor por defecto entre paréntesis:
"controlador": mysql , pgsql , sqlsrv o sqlite ( mysql )
"dirección": Nombre de host (o nombre de archivo) del servidor de base de datos ( localhost )
"puerto": puerto TCP del servidor de base de datos (el valor predeterminado es el controlador predeterminado)
"nombre de usuario": nombre de usuario del usuario que se conecta a la base de datos (sin valor predeterminado)
"contraseña": Contraseña del usuario que se conecta a la base de datos (no predeterminada)
"database": Base de datos a la que se realiza la conexión (sin valor predeterminado)
"comando": SQL adicional para inicializar la conexión de la base de datos (ninguno)
"tablas": lista separada por comas de tablas para publicar (el valor predeterminado es 'todas')
"mapping": lista separada por comas de asignaciones de tablas/columnas (sin asignación)
"geometrySrid": SRID asumido al convertir de WKT a geometría ( 4326 )
"middlewares": Lista de middlewares para cargar ( cors )
"controladores": Lista de controladores para cargar ( records,geojson,openapi,status )
"customControllers": Lista de controladores personalizados de usuario para cargar (sin valor predeterminado)
"openApiBase": información de OpenAPI ( {"info":{"title":"PHP-CRUD-API","version":"1.0.0"}} )
"cacheType": TempFile , Redis , Memcache , Memcached o NoCache ( TempFile )
"cachePath": ruta/dirección del caché (el valor predeterminado es el directorio temporal del sistema)
"cacheTime": Número de segundos que la caché es válida ( 10 )
"jsonOptions": Opciones utilizadas para codificar JSON ( JSON_UNESCAPED_UNICODE )
"depurar": muestra errores en los encabezados "X-Exception" ( false )
"basePath": ruta base URI de la API (determinada usando PATH_INFO de forma predeterminada)
Todas las opciones de configuración también están disponibles como variables de entorno. Escriba la opción de configuración con mayúsculas, un prefijo "PHP_CRUD_API_" y guiones bajos para saltos de palabras, por ejemplo:
PHP_CRUD_API_DRIVER=mysql
PHP_CRUD_API_ADDRESS=host local
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
Las variables de entorno tienen prioridad sobre la configuración de PHP.
Estas limitaciones y restricciones se aplican:
Las claves principales deben ser de incremento automático (de 1 a 2^53) o UUID
No se admiten claves primarias y externas compuestas
No se admiten escrituras (transacciones) complejas
No se admiten consultas complejas que llamen a funciones (como "concat" o "sum")
La base de datos debe soportar y definir restricciones de clave externa.
SQLite no puede tener claves primarias de incremento automático escritas en bigint
SQLite no admite la modificación de columnas de la tabla (estructura)
Se admiten las siguientes funciones:
Instalación de Composer o archivo PHP único, fácil de implementar.
Muy poco código, fácil de adaptar y mantener.
Admite variables POST como entrada (x-www-form-urlencoded)
Admite un objeto JSON como entrada
Admite una matriz JSON como entrada (inserción por lotes)
Desinfecte y valide la entrada usando reglas de tipo y devoluciones de llamada
Sistema de permisos para bases de datos, tablas, columnas y registros.
Se admiten diseños de bases de datos únicas y múltiples de múltiples inquilinos
Soporte CORS multidominio para solicitudes entre dominios
Soporte para leer resultados unidos de múltiples tablas
Soporte de búsqueda según múltiples criterios
Paginación, clasificación, lista N superior y selección de columnas
Detección de relaciones con resultados anidados (belongsTo, hasMany y HABTM)
Soporte de incremento atómico vía PATCH (para contadores)
Campos binarios compatibles con codificación base64
Campos y filtros espaciales/GIS compatibles con WKT y GeoJSON
Asignación de nombres de tablas y columnas para admitir sistemas heredados
Genere documentación API utilizando herramientas OpenAPI
Autenticación mediante clave API, token JWT o nombre de usuario/contraseña
Los parámetros de conexión de la base de datos pueden depender de la autenticación.
Soporte para leer la estructura de la base de datos en JSON.
Soporte para modificar la estructura de la base de datos usando el punto final REST
Se incluye middleware que mejora la seguridad
Cumple con los estándares: PSR-4, PSR-7, PSR-12, PSR-15 y PSR-17
Proyectos relacionados:
Inicio rápido de PHP-CRUD-API: un archivo de composición acoplable personalizable y listo para usar que incluye PHP-CRUD-API.
Generador de filtros PHP-CRUD-API: una biblioteca de JavaScript que crea filtros PHP-CRUD-API a partir de expresiones.
JS-CRUD-API: una biblioteca cliente de JavaScript para la API de PHP-CRUD-API
PHP-API-AUTH: script PHP de archivo único que es un proveedor de autenticación para PHP-CRUD-API
PHP-CRUD-UI: script PHP de archivo único que agrega una interfaz de usuario a un proyecto PHP-CRUD-API.
PHP-CRUD-ADMIN: script PHP de archivo único que agrega una interfaz de administración de base de datos a un proyecto PHP-CRUD-API.
PHP-SP-API: script PHP de archivo único que agrega una API REST a una base de datos SQL.
dexie-mysql-sync: Sincronización entre IndexedDB local y la base de datos MySQL.
ra-data-treeql: paquete NPM que proporciona un proveedor de datos para React Admin.
scriptPilot/vueuse: Vue Composables además de VueUse.org (que admite PHP-CRUD-API).
scriptPilot/add-php-backend: agregue MySQL, phpMyAdmin y PHP-CRUD-API a su entorno de desarrollo.
VUE-CRUD-UI: script Vue.js de archivo único que agrega una interfaz de usuario a un proyecto PHP-CRUD-API.
También hay adaptaciones de este script en:
Go-CRUD-API (trabajo en progreso)
Java JDBC por Ivan Kolchagov (v1)
Java Spring Boot + jOOQ (v2: trabajo en progreso)
También hay versiones de prueba de concepto de este script que solo admiten la funcionalidad REST CRUD básica en: PHP, Java, Go, C# .net core, Node.js y Python.
Puede instalar todas las dependencias de este proyecto usando el siguiente comando:
php install.php
Puede compilar todos los archivos en un único archivo " api.php " usando:
php build.php
Tenga en cuenta que no utiliza la compilación cuando integra este proyecto en otro proyecto o marco (use Composer en su lugar).
Puede acceder al código no compilado en la URL:
http://localhost:8080/src/records/posts/1
El código no compilado reside en los directorios " src " y " vendor ". El directorio " vendor " contiene las dependencias.
Puede actualizar todas las dependencias de este proyecto usando el siguiente comando:
php update.php
Este script instalará y ejecutará Composer para actualizar las dependencias.
NB: el script de actualización parcheará las dependencias en el directorio de proveedores para lograr compatibilidad con PHP 7.0.
TreeQL le permite crear un "árbol" de objetos JSON basado en la estructura de su base de datos SQL (relaciones) y su consulta.
Se basa libremente en el estándar REST y también está inspirado en json:api.
La tabla de publicaciones de ejemplo tiene solo unos pocos campos:
posts ======= id title content created
Las operaciones CRUD + Lista a continuación actúan sobre esta tabla.
Si desea crear un registro, la solicitud se puede escribir en formato URL como:
POST /records/posts
Tienes que enviar un cuerpo que contenga:
{
"title": "Black is the new red",
"content": "This is the second post.",
"created": "2018-03-06T21:34:01Z"
}Y devolverá el valor de la clave principal del registro recién creado:
2
Para leer un registro de esta tabla, la solicitud se puede escribir en formato URL como:
GET /records/posts/1
Donde "1" es el valor de la clave principal del registro que desea leer. Volverá:
{
"id": 1
"title": "Hello world!",
"content": "Welcome to the first post.",
"created": "2018-03-05T20:12:56Z"
}En operaciones de lectura, puede aplicar uniones.
Para actualizar un registro en esta tabla, la solicitud se puede escribir en formato URL como:
PUT /records/posts/1
Donde "1" es el valor de la clave principal del registro que desea actualizar. Enviar como cuerpo:
{
"title": "Adjusted title!"
}Esto ajusta el título de la publicación. Y el valor de retorno es el número de filas que se establecen:
1
Si desea eliminar un registro de esta tabla, la solicitud se puede escribir en formato URL como:
DELETE /records/posts/1
Y devolverá el número de filas eliminadas:
1
Para enumerar registros de esta tabla, la solicitud se puede escribir en formato URL como:
GET /records/posts
Volverá:
{
"records":[
{
"id": 1,
"title": "Hello world!",
"content": "Welcome to the first post.",
"created": "2018-03-05T20:12:56Z"
}
]
}En las operaciones de lista puede aplicar filtros y uniones.
Los filtros proporcionan funcionalidad de búsqueda, en llamadas de lista, utilizando el parámetro "filtro". Debe especificar el nombre de la columna, una coma, el tipo de coincidencia, otra coma y el valor por el que desea filtrar. Estos son los tipos de coincidencias admitidos:
"cs": contiene cadena (la cadena contiene valor)
"sw": comienza con (la cadena comienza con el valor)
"ew": termina con (la cadena termina con valor)
"eq": igual (la cadena o el número coinciden exactamente)
"lt": inferior a (el número es inferior al valor)
"le": menor o igual (el número es menor o igual que el valor)
"ge": mayor o igual (el número es mayor o igual que el valor)
"gt": mayor que (el número es mayor que el valor)
"bt": entre (el número está entre dos valores separados por comas)
"in": en (el número o cadena está en una lista de valores separados por comas)
"is": es nulo (el campo contiene el valor "NULL")
Puede negar todos los filtros anteponiendo un carácter "n", de modo que "eq" se convierta en "neq". Ejemplos de uso de filtros son:
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
Producción:
{
"records":[
{
"id": 1
"name": "Internet"
}
]
}En la siguiente sección, profundizaremos en cómo puede aplicar múltiples filtros en una sola llamada de lista.
Los filtros se pueden aplicar repitiendo el parámetro "filtro" en la URL. Por ejemplo la siguiente URL:
GET /records/categories?filter=id,gt,1&filter=id,lt,3
solicitará todas las categorías "donde id > 1 e id < 3". Si quisieras "donde id = 2 o id = 4" deberías escribir:
GET /records/categories?filter1=id,eq,2&filter2=id,eq,4
Como puede ver, agregamos un número al parámetro "filtro" para indicar que se debe aplicar "O" en lugar de "Y". Tenga en cuenta que también puede repetir "filtro1" y crear un "Y" dentro de un "O". Dado que también puede ir un nivel más profundo agregando una letra (af), puede crear casi cualquier árbol de condiciones razonablemente complejo.
NB: solo puede filtrar en la tabla solicitada (no en las tablas incluidas) y los filtros solo se aplican en las llamadas de lista.
De forma predeterminada, todas las columnas están seleccionadas. Con el parámetro "incluir" puede seleccionar columnas específicas. Puede utilizar un punto para separar el nombre de la tabla del nombre de la columna. Varias columnas deben estar separadas por comas. Se puede utilizar un asterisco ("*") como comodín para indicar "todas las columnas". De manera similar a "incluir", puede usar el parámetro "excluir" para eliminar ciertas columnas:
GET /records/categories/1?include=name GET /records/categories/1?include=categories.name GET /records/categories/1?exclude=categories.id
Producción:
{
"name": "Internet"
}NB: Las columnas que se utilizan para incluir entidades relacionadas se agregan automáticamente y no pueden omitirse en la salida.
Con el parámetro "orden" puedes ordenar. De forma predeterminada, la clasificación es ascendente, pero al especificar "desc" esto se puede revertir:
GET /records/categories?order=name,desc GET /records/categories?order=id,desc&order=name
Producción:
{
"records":[
{
"id": 3
"name": "Web development"
},
{
"id": 1
"name": "Internet"
}
]
}NB: Puede ordenar varios campos utilizando varios parámetros de "orden". No puede realizar pedidos en columnas "unidas".
El parámetro "tamaño" limita el número de registros devueltos. Esto se puede utilizar para las N listas principales junto con el parámetro "orden" (use orden descendente).
GET /records/categories?order=id,desc&size=1
Producción:
{
"records":[
{
"id": 3
"name": "Web development"
}
]
}NB: Si también desea conocer el número total de registros, puede utilizar el parámetro "página".
El parámetro "página" contiene la página solicitada. El tamaño de página predeterminado es 20, pero se puede ajustar (por ejemplo, a 50).
GET /records/categories?order=id&page=1 GET /records/categories?order=id&page=1,50
Producción:
{
"records":[
{
"id": 1
"name": "Internet"
},
{
"id": 3
"name": "Web development"
}
],
"results": 2
}El elemento "resultados" contiene el número total de registros en la tabla, que se devolvería si no se utilizara paginación.
NB: Dado que las páginas que no están ordenadas no se pueden paginar, las páginas se ordenarán por clave principal.
Digamos que tienes una tabla de publicaciones que tiene comentarios (hechos por usuarios) y las publicaciones pueden tener etiquetas.
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
Cuando desee enumerar publicaciones con sus comentarios, usuarios y etiquetas, puede solicitar dos rutas de "árbol":
posts -> comments -> users posts -> post_tags -> tags
Estas rutas tienen la misma raíz y esta solicitud se puede escribir en formato URL como:
GET /records/posts?join=comments,users&join=tags
Aquí puede omitir la tabla intermedia que vincula las publicaciones con las etiquetas. En este ejemplo, verá los tres tipos de relación de tabla (hasMany, pertenece a y hasAndBelongsToMany) en vigor:
"publicación" tiene muchos "comentarios"
"comentario" pertenece al "usuario"
"publicación" tiene y pertenece a muchas "etiquetas"
Esto puede generar los siguientes datos 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"
}
]
}
]
}Verá que se detectan las relaciones "pertenece a" y el valor de la clave externa se reemplaza por el objeto al que se hace referencia. En el caso de "hasMany" y "hasAndBelongsToMany", el nombre de la tabla se utiliza como nueva propiedad en el objeto.
Cuando desee crear, leer, actualizar o eliminar, puede especificar varios valores de clave principal en la URL. También debe enviar una matriz en lugar de un objeto en el cuerpo de la solicitud para su creación y actualización.
Para leer un registro de esta tabla, la solicitud se puede escribir en formato URL como:
GET /records/posts/1,2
El resultado puede 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"
}
]De manera similar, cuando desea realizar una actualización por lotes, la solicitud en formato URL se escribe como:
PUT /records/posts/1,2
Donde "1" y "2" son los valores de las claves primarias de los registros que desea actualizar. El cuerpo debe contener la misma cantidad de objetos que claves principales en la URL:
[
{
"title": "Adjusted title for ID 1"
},
{
"title": "Adjusted title for ID 2"
}
]Esto ajusta los títulos de las publicaciones. Y los valores de retorno son el número de filas que se establecen:
[1,1]
Lo que significa que hubo dos operaciones de actualización y cada una de ellas había establecido una fila. Las operaciones por lotes utilizan transacciones de bases de datos, por lo que todas tienen éxito o todas fallan (las exitosas se revierten). Si fallan, el cuerpo contendrá la lista de documentos de error. En la siguiente respuesta, la primera operación tuvo éxito y la segunda operación del lote falló debido a una violación de integridad:
[
{
"code": 0,
"message": "Success"
},
{
"code": 1010,
"message": "Data integrity violation"
}
]El código de estado de respuesta siempre será 424 (dependencia fallida) en caso de cualquier falla en una de las operaciones por lotes.
Para insertar varios registros en esta tabla, la solicitud se puede escribir en formato URL como:
POST /records/posts
El cuerpo debe contener una serie de registros a insertar:
[
{
"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"
}
]El valor de retorno también es una matriz que contiene las claves principales de los registros recién insertados:
[1,2]
Tenga en cuenta que la operación por lotes para DELETE sigue el mismo patrón que PUT, pero sin cuerpo.
Para soporte espacial, hay un conjunto adicional de filtros que se pueden aplicar en columnas de geometría y que comienzan con una "s":
"sco": contiene espacial (la geometría contiene otra)
"scr": cruces espaciales (una geometría cruza otra)
"sdi": espacial disjunta (una geometría es disjunta de otra)
"seq": espacial igual (la geometría es igual a otra)
"pecado": intersecciones espaciales (la geometría se cruza con otra)
"sov": superposiciones espaciales (la geometría se superpone a otra)
"sto": toques espaciales (la geometría toca a otra)
"swi": espacial dentro (la geometría está dentro de otra)
"sic": espacial es cerrado (la geometría es cerrada y simple)
"sis": espacial es simple (la geometría es simple)
"siv": espacial es válido (la geometría es válida)
Estos filtros se basan en los estándares OGC y también lo está la especificación WKT en la que se representan las columnas de geometría. Tenga en cuenta que el SRID que se asume al convertir de WKT a geometría se especifica mediante la variable de configuración geometrySrid y el valor predeterminado es 4326 (WGS 84).
La compatibilidad con GeoJSON es una vista de solo lectura de las tablas y registros en formato GeoJSON. Estas solicitudes son compatibles:
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 El punto final " /geojson " utiliza el punto final " /records " internamente y hereda todas las funciones, como uniones y filtros. También admite un parámetro "geometría" para indicar el nombre de la columna de geometría en caso de que la tabla tenga más de una. Para vistas de mapas, admite el parámetro "bbox" en el que puede especificar las coordenadas superior izquierda e inferior derecha (separadas por comas). La implementación GeoJSON admite los siguientes tipos de geometría:
Punto
Multipunto
cadena de línea
cadena multilínea
Polígono
Multipolígono
La funcionalidad GeoJSON está habilitada de forma predeterminada, pero se puede deshabilitar usando la configuración de "controladores".
Para admitir la creación de una API para (una parte de) un sistema heredado (como Wordpress), es posible que desee asignar los nombres de tablas y columnas, ya que no se pueden mejorar sin cambiar el software, mientras que los nombres pueden necesitar alguna mejora para mantener la coherencia. La configuración le permite cambiar el nombre de tablas y columnas con una lista de asignaciones separadas por comas que se dividen con un signo igual, como esta:
'mapping' => 'wp_posts=posts,wp_posts.ID=posts.id',
Este ejemplo específico expondrá la tabla " wp_posts " en un punto final " posts " (en lugar de " wp_posts ") y la columna " ID " dentro de esa tabla como la propiedad " id " (en minúsculas en lugar de mayúsculas).
NB: Dado que estas dos asignaciones se superponen, la primera (menos específica) puede omitirse.
Puede habilitar el siguiente middleware utilizando el parámetro de configuración "middlewares":
"firewall": limita el acceso a direcciones IP específicas
"sslRedirect": fuerza la conexión a través de HTTPS en lugar de HTTP
"cors": soporte para solicitudes CORS (habilitado de forma predeterminada)
"xsrf": bloquea los ataques XSRF utilizando el método 'Double Submit Cookie'
"ajaxOnly": restringe las solicitudes que no sean AJAX para evitar ataques XSRF
"apiKeyAuth": Compatibilidad con "Autenticación de clave API"
"apiKeyDbAuth": compatibilidad con "Autenticación de base de datos de claves API"
"dbAuth": Compatibilidad con "Autenticación de base de datos"
"wpAuth": Soporte para "Autenticación de WordPress"
"jwtAuth": Compatibilidad con "Autenticación JWT"
"basicAuth": Soporte para "Autenticación básica"
"reconnect": Vuelve a conectarte a la base de datos con diferentes parámetros
"autorización": Restringir el acceso a ciertas tablas o columnas
"validación": Devuelve errores de validación de entrada para reglas personalizadas y reglas de tipo predeterminadas
"ipAddress": complete un campo protegido con la dirección IP al crear
"saneamiento": Aplicar saneamiento de entrada al crear y actualizar
"multiTenancy": restringe el acceso de los inquilinos en un escenario multiinquilino
"pageLimits": restringe las operaciones de lista para evitar el raspado de la base de datos
"joinLimits": restringe los parámetros de unión para evitar el raspado de la base de datos
"textSearch": busca en todos los campos de texto con un parámetro simple
"personalización": proporciona controladores para la personalización de solicitudes y respuestas
"json": admite lectura/escritura de cadenas JSON como objetos/matrices JSON
"xml": traduce todas las entradas y salidas de JSON a XML
El parámetro de configuración "middlewares" es una lista separada por comas de middlewares habilitados. Puede ajustar el comportamiento del middleware utilizando parámetros de configuración específicos del middleware:
"firewall.reverseProxy": se establece en "true" cuando se utiliza un proxy inverso ("")
"firewall.allowedIpAddresses": Lista de direcciones IP que pueden conectarse ("")
"cors.allowedOrigins": Los orígenes permitidos en los encabezados CORS ("*")
"cors.allowHeaders": los encabezados permitidos en la solicitud CORS ("Content-Type, X-XSRF-TOKEN, X-Authorization")
"cors.allowMethods": Los métodos permitidos en la solicitud CORS ("OPCIONES, GET, PUT, POST, DELETE, PATCH")
"cors.allowCredentials": para permitir credenciales en la solicitud CORS ("true")
"cors.exposeHeaders": encabezados de la lista blanca a los que los navegadores pueden acceder ("")
"cors.maxAge": el tiempo que la concesión CORS es válida en segundos ("1728000")
"xsrf.excludeMethods": Los métodos que no requieren protección XSRF ("OPCIONES, GET")
"xsrf.cookieName": El nombre de la cookie de protección XSRF ("XSRF-TOKEN")
"xsrf.headerName": el nombre del encabezado de protección XSRF ("X-XSRF-TOKEN")
"ajaxOnly.excludeMethods": Los métodos que no requieren AJAX ("OPCIONES, GET")
"ajaxOnly.headerName": el nombre del encabezado requerido ("X-Requested-With")
"ajaxOnly.headerValue": el valor del encabezado requerido ("XMLHttpRequest")
"apiKeyAuth.mode": configúrelo como "opcional" si desea permitir el acceso anónimo ("obligatorio")
"apiKeyAuth.header": el nombre del encabezado de la clave API ("X-API-Key")
"apiKeyAuth.keys": Lista de claves API que son válidas ("")
"apiKeyDbAuth.mode": configúrelo como "opcional" si desea permitir el acceso anónimo ("obligatorio")
"apiKeyDbAuth.header": el nombre del encabezado de la clave API ("X-API-Key")
"apiKeyDbAuth.usersTable": la tabla que se utiliza para almacenar los usuarios ("usuarios")
"apiKeyDbAuth.apiKeyColumn": la columna de la tabla de usuarios que contiene la clave API ("api_key")
"dbAuth.mode": configúrelo como "opcional" si desea permitir el acceso anónimo ("obligatorio")
"dbAuth.usersTable": la tabla que se utiliza para almacenar los usuarios ("usuarios")
"dbAuth.loginTable": la tabla o vista que se utiliza para recuperar la información de los usuarios para iniciar sesión ("usuarios")
"dbAuth.usernameColumn": la columna de la tabla de usuarios que contiene los nombres de usuario ("nombre de usuario")
"dbAuth.passwordColumn": la columna de la tabla de usuarios que contiene las contraseñas ("contraseña")
"dbAuth.returnedColumns": las columnas devueltas al iniciar sesión correctamente, vacías significa 'todas' ("")
"dbAuth.usernameFormField": el nombre del campo del formulario que contiene el nombre de usuario ("nombre de usuario")
"dbAuth.passwordFormField": el nombre del campo del formulario que contiene la contraseña ("contraseña")
"dbAuth.newPasswordFormField": el nombre del campo del formulario que contiene la nueva contraseña ("newPassword")
"dbAuth.registerUser": datos de usuario JSON (o "1") en caso de que desee habilitar el punto final /register ("")
"dbAuth.loginAfterRegistration": 1 o cero si los usuarios registrados deben iniciar sesión después del registro ("")
"dbAuth.passwordLength": Longitud mínima que debe tener la contraseña ("12")
"dbAuth.sessionName": El nombre de la sesión PHP que se inicia ("")
"wpAuth.mode": configúrelo como "opcional" si desea permitir el acceso anónimo ("obligatorio")
"wpAuth.wpDirectory": La carpeta/ruta donde se puede encontrar la instalación de Wordpress (".")
"wpAuth.usernameFormField": el nombre del campo del formulario que contiene el nombre de usuario ("nombre de usuario")
"wpAuth.passwordFormField": el nombre del campo del formulario que contiene la contraseña ("contraseña")
"jwtAuth.mode": configúrelo como "opcional" si desea permitir el acceso anónimo ("obligatorio")
"jwtAuth.header": Nombre del encabezado que contiene el token JWT ("Autorización X")
"jwtAuth.leeway": el número aceptable de segundos de desviación del reloj ("5")
"jwtAuth.ttl": el número de segundos que el token es válido ("30")
"jwtAuth.secrets": Los secretos compartidos utilizados para firmar el token JWT con ("")
"jwtAuth.algorithms": Los algoritmos que están permitidos, vacío significa 'todos' ("")
"jwtAuth.audiences": Las audiencias permitidas, vacías significa 'todas' ("")
"jwtAuth.issuers": Los emisores permitidos, vacío significa 'todos' ("")
"jwtAuth.sessionName": El nombre de la sesión PHP que se inicia ("")
"basicAuth.mode": configúrelo como "opcional" si desea permitir el acceso anónimo ("obligatorio")
"basicAuth.realm": texto que se solicita al mostrar el inicio de sesión ("Se requiere nombre de usuario y contraseña")
"basicAuth.passwordFile": el archivo a leer para combinaciones de nombre de usuario/contraseña (".htpasswd")
"basicAuth.sessionName": El nombre de la sesión PHP que se inicia ("")
"reconnect.driverHandler": controlador para implementar la recuperación del controlador de la base de datos ("")
"reconnect.addressHandler": controlador para implementar la recuperación de la dirección de la base de datos ("")
"reconnect.portHandler": controlador para implementar la recuperación del puerto de la base de datos ("")
"reconnect.databaseHandler": controlador para implementar la recuperación del nombre de la base de datos ("")
"reconnect.tablesHandler": controlador para implementar la recuperación de los nombres de las tablas ("")
"reconnect.mappingHandler": controlador para implementar la recuperación de la asignación de nombres ("")
"reconnect.usernameHandler": controlador para implementar la recuperación del nombre de usuario de la base de datos ("")
"reconnect.passwordHandler": controlador para implementar la recuperación de la contraseña de la base de datos ("")
"authorization.tableHandler": Controlador para implementar reglas de autorización de tablas ("")
"authorization.columnHandler": Controlador para implementar reglas de autorización de columnas ("")
"authorization.pathHandler": controlador para implementar reglas de autorización de ruta ("")
"authorization.recordHandler": controlador para implementar reglas de filtro de autorización de registros ("")
"validation.handler": Controlador para implementar reglas de validación para valores de entrada ("")
"validation.types": tipos para habilitar la validación de tipos, vacío significa 'ninguno' ("todos")
"validation.tables": Tablas para habilitar la validación de tipos, vacías significa "ninguna" ("todas")
"ipAddress.tables": Tablas para buscar columnas para anular con la dirección IP ("")
"ipAddress.columns": Columnas para proteger y anular con la dirección IP al crear ("")
"sanitation.handler": controlador para implementar reglas de saneamiento para los valores de entrada ("")
"sanitation.types": tipos para habilitar el tipo de saneamiento, vacío significa 'ninguno' ("todos")
"sanitation.tables": Tablas para habilitar el tipo de saneamiento, vacías significa "ninguno" ("todos")
"multiTenancy.handler": Controlador para implementar reglas simples de arrendamiento múltiple ("")
"pageLimits.pages": el número máximo de páginas que permite una operación de lista ("100")
"pageLimits.records": el número máximo de registros devueltos por una operación de lista ("1000")
"joinLimits. Depth": la profundidad (longitud) máxima permitida en una ruta de unión ("3")
"joinLimits.tables": el número máximo de tablas a las que puede unirse ("10")
"joinLimits.records": el número máximo de registros devueltos para una entidad unida ("1000")
"textSearch.parameter": el nombre del parámetro utilizado para el término de búsqueda ("búsqueda")
"customization.beforeHandler": controlador para implementar la personalización de solicitudes ("")
"customization.afterHandler": Controlador para implementar la personalización de la respuesta ("")
"json.controllers": Controladores para procesar cadenas JSON ("records,geojson")
"json.tables": Tablas para procesar cadenas JSON para ("todos")
"json.columns": columnas para procesar cadenas JSON ("todos")
"xml.types": tipos JSON que deben agregarse al atributo de tipo XML ("null,array")
Si no especifica estos parámetros en la configuración, se utilizan los valores predeterminados (entre paréntesis).
En las secciones siguientes encontrará más información sobre el middleware integrado.
Actualmente se admiten cinco tipos de autenticación. Todos almacenan al usuario autenticado en el superglobal $_SESSION . Esta variable se puede utilizar en los controladores de autorización para decidir si alguien debería tener acceso de lectura o escritura a determinadas tablas, columnas o registros. La siguiente descripción general muestra los tipos de middleware de autenticación que puede habilitar.
| Nombre | software intermedio | Autenticado mediante | Los usuarios se almacenan en | variable de sesión |
|---|---|---|---|---|
| clave API | apiKeyAuth | Encabezado 'X-API-Key' | configuración | $_SESSION['apiKey'] |
| Base de datos de clave API | apiKeyDbAuth | Encabezado 'X-API-Key' | tabla de base de datos | $_SESSION['apiUser'] |
| Base de datos | autenticación db | Punto final '/iniciar sesión' | tabla de base de datos | $_SESSION['user'] |
| Básico | autenticación básica | Encabezado 'Autorización' | Archivo '.htpasswd' | $_SESSION['username'] |
| JWT | jwtAuth | Encabezado 'Autorización' | proveedor de identidad | $_SESSION['claims'] |
A continuación encontrará más información sobre cada uno de los tipos de autenticación.
La autenticación de clave API funciona enviando una clave API en un encabezado de solicitud. El nombre del encabezado por defecto es "X-API-Key" y se puede configurar utilizando el parámetro de configuración 'apiKeyAuth.header'. Las claves API válidas se deben configurar utilizando el parámetro de configuración 'apiKeyAuth.keys' (lista separada por comas).
X-API-Key: 02c042aa-c3c2-4d11-9dae-1a6e230ea95e
La clave API autenticada se almacenará en la variable $_SESSION['apiKey'] .
Tenga en cuenta que la autenticación de clave API no requiere ni utiliza cookies de sesión.
La autenticación de la base de datos de claves API funciona enviando una clave API en un encabezado de solicitud "X-API-Key" (el nombre es configurable). Las claves API válidas se leen de la base de datos desde la columna "api_key" de la tabla "usuarios" (ambos nombres son configurables).
X-API-Key: 02c042aa-c3c2-4d11-9dae-1a6e230ea95e
El usuario autenticado (con todas sus propiedades) se almacenará en la variable $_SESSION['apiUser'] .
Tenga en cuenta que la autenticación de la base de datos de claves API no requiere ni utiliza cookies de sesión.
El middleware de autenticación de bases de datos define cinco nuevas rutas:
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
Un usuario puede iniciar sesión enviando su nombre de usuario y contraseña al punto final de inicio de sesión (en formato JSON). El usuario autenticado (con todas sus propiedades) se almacenará en la variable $_SESSION['user'] . Se puede cerrar la sesión del usuario enviando una solicitud POST con un cuerpo vacío al punto final de cierre de sesión. Las contraseñas se almacenan como hashes en la columna de contraseñas de la tabla de usuarios. Puede registrar un nuevo usuario utilizando el punto final de registro, pero esta funcionalidad debe activarse mediante el parámetro de configuración "dbAuth.registerUser".
Es IMPORTANTE restringir el acceso a la tabla de usuarios utilizando el middleware de 'autorización'; de lo contrario, todos los usuarios pueden agregar, modificar o eliminar libremente cualquier cuenta. La configuración mínima se muestra a continuación:
'middlewares' => 'dbAuth,authorization',
'authorization.tableHandler' => function ($operation, $tableName) {
return $tableName != 'users';
},Tenga en cuenta que este middleware utiliza cookies de sesión y almacena el estado de inicio de sesión en el servidor.
Inicie sesión usando vistas con tabla unida
Para las operaciones de inicio de sesión, es posible utilizar una vista como la tabla de usuarios. Dicha vista puede devolver un resultado filtrado de la tabla de usuarios, por ejemplo, donde activo = verdadero o también puede devolver un resultado de varias tablas a través de una combinación de tablas. Como mínimo, la vista debe incluir el nombre de usuario y la contraseña y un campo denominado id .
Sin embargo, las vistas con tablas unidas no se pueden insertar (consulte el problema 907). Como solución alternativa, utilice la propiedad loginTable para establecer una tabla de referencia diferente para iniciar sesión. La tabla de usuarios seguirá configurada en la tabla de usuarios insertable normal.
El middleware de autenticación de Wordpress define tres rutas:
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
Un usuario puede iniciar sesión enviando su nombre de usuario y contraseña al punto final de inicio de sesión (en formato JSON). Se puede cerrar la sesión del usuario enviando una solicitud POST con un cuerpo vacío al punto final de cierre de sesión. Debe especificar el directorio de instalación de Wordpress utilizando el parámetro de configuración "wpAuth.wpDirectory". El middleware llama "wp-load.php", esto le permite usar funciones de Wordpress en el middleware de autorización, como:
wp_get_current_user()
is_user_logged_in()
es_super_admin()
user_can(wp_get_current_user(),'edit_posts');
Tenga en cuenta que este middleware no utiliza la variable $_SESSION .
El tipo Básico admite un archivo (por defecto '.htpasswd') que contiene los usuarios y sus contraseñas (en hash) separados por dos puntos (':'). Cuando las contraseñas se ingresan en texto sin formato, se codificarán automáticamente. El nombre de usuario autenticado se almacenará en la variable $_SESSION['username'] . Debe enviar un encabezado de "Autorización" que contenga una versión codificada en URL base64 de su nombre de usuario y contraseña separados por dos puntos, después de la palabra "Básico".
Authorization: Basic dXNlcm5hbWUxOnBhc3N3b3JkMQ
Este ejemplo envía la cadena "nombre de usuario1:contraseña1".
El tipo JWT requiere otro servidor (SSO/Identidad) para firmar un token que contiene notificaciones. Ambos servidores comparten un secreto para poder firmar o verificar que la firma es válida. Los reclamos se almacenan en la variable $_SESSION['claims'] . Debe enviar un encabezado de "Autorización X" que contenga una URL codificada en base64 y un encabezado, cuerpo y firma del token separados por puntos después de la palabra "Portador" (lea más sobre JWT aquí). El estándar dice que es necesario utilizar el encabezado "Autorización", pero esto es problemático en Apache y PHP.
X-Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6IjE1MzgyMDc2MDUiLCJleHAiOjE1MzgyMDc2MzV9.Z5px_GT15TRKhJCTHhDt5Z6K6LRDSFnLj8U5ok9l7gw
Este ejemplo envía los reclamos firmados:
{
"sub": "1234567890",
"name": "John Doe",
"admin": true,
"iat": "1538207605",
"exp": 1538207635
}NB: La implementación JWT solo admite algoritmos basados en RSA y HMAC.
