Filtrado de Precios con Rango Usando Between en Time Wareham

Curso de NestJS: Persistencia de Datos con TypeORM

Contenido del curso

Introducción

Database

TypeORM

Migraciones

Relaciones

Consultas

Migración a NestJS 9 y TypeORM 0.3

Próximos pasos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:16

Filtrado de Precios con Rango Usando Between en Time Wareham

Curso de NestJS: Persistencia de Datos con TypeORM

Clase 28 de 36

Clase 28 / 36

Recursos

Cuando necesitas filtrar productos dentro de un rango de precios específico, TypeORM ofrece operadores avanzados que simplifican esta tarea de forma elegante. Aprender a utilizar el operador Between y a construir condiciones dinámicas en tus consultas es fundamental para crear APIs robustas y flexibles.

¿Cómo funcionan las opciones avanzadas de búsqueda en TypeORM?

TypeORM proporciona dos niveles de búsqueda en sus repositorios. El nivel básico permite usar la cláusula where para filtrar por condiciones simples. Sin embargo, la parte avanzada incluye operadores SQL como Not, MoreThan, LessThan, MoreThanOrEqual y, el protagonista aquí, Between [01:10].

El operador Between permite definir un rango con un valor mínimo y un valor máximo. TypeORM traduce esto directamente a una sentencia SQL BETWEEN, lo que resulta ideal para filtrar precios, fechas o cualquier campo numérico.

¿Cómo configurar los DTOs para recibir un rango de precios?

El primer paso es agregar dos nuevos parámetros al DTO de filtros: minPrice y maxPrice [01:48]. Ambos se definen como positivos usando el decorador IsPositive() de class-validator, lo que impide enviar valores como cero o negativos.

¿Qué es ValidateIf y cómo garantiza que ambos valores lleguen juntos?

Una situación común es que si el usuario envía un precio mínimo, obligatoriamente debe enviar también el precio máximo para que el rango tenga sentido. Para esto se utiliza el decorador @ValidateIf() de class-validator [02:30]:

typescript @ValidateIf((item) => item.minPrice) @IsPositive() maxPrice: number;

Este decorador recibe una función que evalúa los atributos del DTO. En este caso, indica que maxPrice solo será validado (y por tanto requerido) cuando minPrice esté presente. Si no se envía minPrice, maxPrice tampoco será obligatorio.

¿Cómo construir un where dinámico en el servicio?

En lugar de tener un where fijo, la mejor práctica es construirlo de forma dinámica [03:30]. Esto permite agregar condiciones según los filtros que lleguen, ya sea por precio, marca, categoría u otro atributo:

typescript import { Between, FindOptionsWhere } from 'typeorm';

const where: FindOptionsWhere<Product> = {};

if (minPrice && maxPrice) { where.price = Between(minPrice, maxPrice); }

return this.productRepository.find({ where });

El tipo FindOptionsWhere (referido en la clase como FindConditions) permite tipar correctamente el objeto where con base en los atributos de la entidad Product [04:00]. Gracias a este tipado, al escribir where. el autocompletado mostrará únicamente las propiedades válidas del producto, lo que reduce errores.

Si ningún filtro está presente, el objeto where se envía vacío y la consulta retorna todos los registros sin restricciones.

¿Cómo probar el filtrado por rango en la práctica?

Al realizar pruebas con un cliente HTTP como Insomnia, se puede verificar el comportamiento del filtro [05:18]:

Enviar solo minPrice sin maxPrice: la validación con @ValidateIf() impide la petición y devuelve un error indicando que maxPrice es obligatorio.
Enviar minPrice=1 y maxPrice=20: retorna todos los productos con precio entre 1 y 20.
Enviar minPrice=0: el decorador @IsPositive() rechaza la petición porque cero no es un número positivo [06:10].
Enviar minPrice=200 y maxPrice=250: retorna únicamente los productos dentro de ese rango específico [07:20].

Estos resultados confirman que tanto las validaciones del DTO como el operador Between funcionan correctamente en conjunto.

Para depuración, se puede agregar un console.log que muestre los valores de minPrice y maxPrice tal como llegan al servicio, lo cual ayuda a identificar problemas rápidamente [07:40].

TypeORM ofrece muchos más operadores avanzados además de Between, como In, Like, IsNull o Raw. Te invito a revisar la documentación oficial y experimentar con diferentes combinaciones para construir filtros cada vez más potentes en tus APIs. ¿Qué otros operadores te parecen útiles para tus proyectos?

Jairo Campos Ruiz

Hace 4 años

Aquí dejo un ejemplo con más condiciones, con ordenamiento y alguna que otra cosa más:

Para dividir un poco el Dto me cree una clase de la que heredarán los otros filter con limit y offset ya que estos son muy comunes en cualquier filtro

import { IsOptional, IsPositive, Min } from 'class-validator';
import { ApiProperty } from '@nestjs/swagger';

export class BaseFilterDto {
  @ApiProperty()
  @IsOptional()
  @IsPositive()
  readonly limit: number;

  @ApiProperty()
  @IsOptional()
  @Min(0)
  readonly offset: number;
}

Al Dto de filtrar productos le añadí varias opciones más como que puedas pasar solo un minimo o maximo precio, ordenar por un parámetro en concreto, orden descendente o ascendente y buscar por id de marca.

export class FilterProductsDto extends BaseFilterDto {
  @ApiProperty()
  @IsOptional()
  @Min(0)
  readonly minPrice: number;

  @ApiProperty()
  @IsOptional()
  @IsPositive()
  readonly maxPrice: number;

  @ApiProperty({ enum: ['price', 'id'] })
  @ValidateIf((item) => item.order)
  @IsEnum(['price', 'id'])
  readonly orderBy: string;

  @ApiProperty({ enum: ['ASC', 'DESC'] })
  @ValidateIf((item) => item.orderBy)
  @IsEnum(['ASC', 'DESC'])
  readonly order: string;

  @ApiProperty()
  @IsOptional()
  @IsNumber()
  readonly brandId: number;
}

Para terminar el service me queda de la siguiente manera:

async findAll(params?: FilterProductsDto) {
    const { limit, offset, maxPrice, minPrice, orderBy, order, brandId } =
      params;
    const findOptions: FindManyOptions<Product> = {};

    const where: FindConditions<Product> = {};
    if (minPrice && maxPrice) {
      where.price = Between(minPrice, maxPrice);
    } else if (minPrice) {
      where.price = MoreThanOrEqual(minPrice);
    } else if (maxPrice) {
      where.price = LessThanOrEqual(maxPrice);
    }

    if (brandId) where.brand = { id: brandId };
    if (orderBy && order) findOptions.order = { [orderBy]: order };
    findOptions.where = where;
    findOptions.skip = offset;
    findOptions.take = limit;
    findOptions.relations = ['brand', 'categories'];

    return await this.productRepository.find(findOptions);
  }

Andres Trujillo

Hace 3 años

Uf bro, interesante la implementación!

Comentarios (12)12 comentarios

Hanier Morales

Ángel David Roque Ayala

Hace 5 años

Jordan Salazar

Andrés Esteban Rodríguez Jiménez

Nahuel Soma

Juan Collado

Renato Renzo Luna Herrera

Nicolas Mendoza

Vanessa Paola Oliveros Padron

Hace 2 años

DIEGO MAX NEYRA CORSINO

ZANONI ALFREDO SALAS TOBÓN

Ricardo Tribaldos Hernández

Gerardo Ferreyra

Introducción

Conexiones a Bases de Datos con Time OEM y NetsGIS

Integración de Datos con Next.js y Time ORM en Proyectos E-commerce

Database

Instalación de Docker en Windows, macOS y Ubuntu

Configuración de Postgres en Docker Compose

Conexión a Postgres en Docker: Terminal y PgAdmin

Conexión de NestJS a Postgres con Node Postgres

Inyección de Dependencias en NETJS: Conexión a PostgreSQL

Conexión a Bases de Datos con Variables de Entorno en Node.js

TypeORM

Implementación de TypeORM con NestJS en Proyectos Node.js

Creación de Entidades en ORM para Tiendas Virtuales

Implementación del Patrón Repository en NestJS con TypeORM

Operaciones CRUD en ProductService usando TypeORM y Postgres

Cambio de Postgres a MySQL en Docker para CRUD de Productos

Migraciones

Configuración de Migraciones en Bases de Datos con TimeORM

Configuración y uso de migraciones con TimeORM y TypeScript

Ejecución y gestión de migraciones con Time1M en Node.js

Migraciones en bases de datos: agregar campos automáticamente

Relaciones

Relaciones 1 a 1 en Bases de Datos con TimeORM

Manipulación de Relaciones Uno a Uno en Controladores y Servicios

Relaciones Uno a Muchos en Bases de Datos con TypeORM

Gestión de Relaciones Uno a Muchos en Controladores de API

Relaciones Muchos a Muchos en Time1M: Creación y Manejo Práctico

Manipulación de Relaciones Muchos a Muchos en Controladores

Manipulación de Relaciones Muchos a Muchos con TimeORM en JavaScript

Relaciones Muchos a Muchos con Campos Agregados en TimeWareM

CRUD de órdenes de compra y gestión de ítems en NestJS

Consultas

Paginación de Productos con Limit y Offset en Controladores API

Filtrado de Precios con Rango Usando Between en Time Wareham

Indexación de Parámetros en Bases de Datos: Uso y Precauciones

Buenas prácticas de nombramiento en JavaScript y bases de datos

Serialización y Transformación de Datos en APIs con ClassTransformer

Migración a NestJS 9 y TypeORM 0.3

Actualización de dependencias en NEST y TimeWareM

Migración y ajustes en TimewareM 0.3: Cambios en métodos y servicios

Actualización de Migraciones en TimeWareM 0.3

Próximos pasos

Soluciones a referencias circulares en módulos NestJS

Persistencia de Datos con Time Ware M: Conexiones y Buenas Prácticas

Filtrado de Precios con Rango Usando Between en Time Wareham