Máximo número de variables aceptadas en ExpressJS enviadas por QueryString

Si estás utilizando ExpressJS en sus versiones 3.x y 4.x, debes considerar cómo Express utiliza el paquete qs para analizar los parámetros de consulta. En este artículo, exploraremos cómo Express maneja los query strings y cuáles son los límites preestablecidos por el paquete qs.

Limitaciones en el análisis de query strings

El paquete qs en Express tiene limitaciones importantes al analizar los query strings. Por defecto, el paquete tiene un límite de cinco niveles de profundidad al analizar objetos anidados. Además, al analizar arreglos, se limita el análisis a un máximo de 20 elementos. Si un arreglo tiene más de 20 elementos, el paquete "qs" lo convertirá en un objeto con índices como claves. Esto puede resultar en problemas, incluida la posibilidad de que las claves queden vacías.

Elegir entre GET y POST

Cuando haces una solicitud HTTP, puedes enviar datos a través del cuerpo del mensaje POST o mediante una cadena de consulta en una solicitud GET. Para datos complejos, el método POST suele ser más adecuado, ya que las limitaciones de tamaño de la URL pueden hacer que las cadenas de consulta sean ineficientes para datos grandes. Sin embargo, las solicitudes GET con cadenas de consulta son útiles cuando necesitas compartir y reutilizar enlaces.

Ejemplo práctico

Un ejemplo de uso de cadenas de consulta en una solicitud GET sería:

HTTP GET http://ejemplo.com?productos[]=zapatos&productos[]=camisas

Esto se convierte en el siguiente objeto JavaScript:

{productos: ['zapatos', 'camisas']}

Límites de análisis de objetos

En las solicitudes GET con objetos anidados, el paquete "qs" tiene un límite predeterminado de cinco niveles de profundidad. Este límite evita posibles abusos y mejora la seguridad.

Para superar este límite, puedes proporcionar una opción de profundidad a qs.parse(cadena, [opciones]). Este límite es importante para prevenir abusos y mantener la seguridad.

Previniendo abusos en el análisis

El límite de profundidad mencionado anteriormente es crucial para prevenir posibles abusos. Imagina un ataque en el que alguien intenta sobrecargar tu servidor con objetos anidados excesivamente profundos. El límite de profundidad evita que el servidor colapse al analizar entradas maliciosas.

Límites de análisis de arreglos

"qs" también establece límites en el análisis de arreglos en las cadenas de consulta. Un arreglo puede especificar índices solo hasta un máximo de 20. Cualquier índice por encima de 20 convierte el miembro del arreglo en un objeto con el índice como clave.

Ejemplos de Análisis de Arreglos

Aquí presentamos algunos ejemplos para ilustrar cómo "qs" analiza arreglos:

Ejemplo 1: Arreglo definido con la misma clave utilizando corchetes y varios valores

HTTP GET http://ejemplo.com?arr[]=1&arr[]=2&arr[]=3&...&arr[]=21&arr[]=22

Se analiza como:

{arr: [1, 2, 3, ..., 21, 22]}

Ejemplo 2: Arreglo definido con la misma clave utilizando varios valores

HTTP GET http://ejemplo.com?arr=1&arr=2&arr=3&...&arr=21&arr=22

Se analiza como:

{arr: [1, 2, 3, ..., 21, 22]}

Ejemplo 3: Arreglo definido utilizando corchetes e índices en la misma clave con múltiples valores

HTTP GET http://ejemplo.com?arr[0]=1&arr[1]=2&arr[2]=3&...&arr[20]=21&arr[21]=22

Se analiza como:

{
  arr: {
    0: "1",
    1: "2",
    2: "3",
    ...,
    20: "21",
    21: "22"
  }
}

Soluciones para Superar Límites

A continuación, se presentan dos soluciones para manejar arreglos grandes en cadenas de consulta utilizando Express:

1. Object.values()

Una solución rápida es utilizar "Object.values()" para obtener siempre un arreglo.

Ejemplo: Cómo funciona "Object.values()"

const arreglo = [1, 2, 3];
const objeto = {a: 1, b: 2, c: 3};

console.log(Object.values(arreglo)); // imprime [1, 2, 3]
console.log(Object.values(objeto)); // imprime [1, 2, 3]

Ejemplo: Manejo en una solicitud de ejemplo

app.get('/ruta', (req, res) => {
  const miGranArreglo = Object.values(req.query.bigArray);
  // ...
});

Esta solución puede no ser la más eficiente, ya que requiere ajustar los datos de la consulta en varios manejadores de solicitudes diferentes. Pero puede ser útil en situaciones específicas. La siguiente solución es más efectiva.

2. Middleware de analizador de consultas personalizado

Se puede definir un analizador de consultas personalizado, como se muestra en el siguiente código.

const app = express();

app.set('query parser', function (str) {
  return qs.parse(str, { arrayLimit: 0 });
});

Conclusión

En general, es recomendable evitar cadenas de consulta con datos demasiado complejos o con una profundidad anidada excesiva. Si decides utilizar datos complejos en una cadena de consulta y estás trabajando con Express 3 o 4, debes considerar las configuraciones predeterminadas del paquete "qs" para prevenir posibles problemas. Lo mejor es mantener las cadenas de consulta simples y utilizar POST cuando se necesite enviar datos más complejos.

Happy coding! :D

Photo by Arisa Chattasa on Unsplash