Filtrado de Precios con Rango Usando Between en Time Wareham

Clase 28 de 36 • Curso de NestJS: Persistencia de Datos con TypeORM

Resumen

¿Cómo filtrar precios por rango utilizando TypeORM?

Filtrar datos por rangos es una práctica común y esencial en el desarrollo de aplicaciones que manejan grandes volúmenes de datos. En este contexto, aprenderemos a utilizar TypeORM para filtrar precios dentro de un rango específico. Esto se logra con el uso de la cláusula BETWEEN, una herramienta poderosa para obtener los resultados deseados de manera eficiente y precisa.

¿Cómo configurar el DTO para los filtros de precios?

La configuración del DTO (Objeto de Transferencia de Datos) es el primer paso para recibir y validar correctamente los parámetros de entrada. En este caso, configuraremos dos parámetros opcionales: MINPRICE y MAXPRICE. Aquí te explicamos cómo:

Definición de parámetros: Se agregan MINPRICE y MAXPRICE como parámetros opcionales con la cláusula isPositive() para asegurar que los valores sean positivos.
Validación condicional: Utilizamos el decorador VALIDATEIF de ClassValidator para asegurar que si se proporciona MINPRICE, MAXPRICE también debe estar presente, garantizando que siempre se tenga un rango completo.

@IsOptional()
@IsPositive()
minPrice: number;

@ValidateIf(o => o.minPrice !== undefined)
@IsPositive()
maxPrice: number;

¿Cómo implementar el filtro con TypeORM?

Al establecer filtros en consultas, es fundamental hacerlo de manera dinámica para permitir flexibilidad en las búsquedas. Aquí te mostramos cómo:

Importar y configurar Between: Primero importamos el método Between de TypeORM, que nos facilita establecer las condiciones de búsqueda por rango.
Crear condiciones dinámicas: Se inicia con una condición WHERE vacía que se llenará dinámicamente dependiendo de los filtros recibidos. Esto no solo te permitirá buscar por precio, sino que mantendrá el código limpio y escalable para futuras extensiones, como filtrar por marca o categoría.

import { Between, FindConditions } from 'typeorm';

// Crear un objeto WHERE inicialmente vacío
let where: FindConditions<Product> = {};

// Si existen MINPRICE y MAXPRICE, agregar la condición WHERE
if (minPrice !== undefined && maxPrice !== undefined) {
    where.price = Between(minPrice, maxPrice);
}
// Ejecutar query usando el objeto WHERE

¿Cómo verificar la funcionalidad y debuggear?

Verificar que todo funcione como debería es crucial. Usando una herramienta como Insomnia para simular solicitudes HTTP, podrás asegurar que tu API responde correctamente a los parámetros de entrada.

Verificación de parámetros: A través de pruebas de solicitudes, puedes verificar que al ingresar un MINPRICE, se exige un MAXPRICE antes de proceder. Además, la validación de positividad garantiza que no se permitan valores negativos o cero.
Console.log para Depuración: Añadir un console.log para mostrar los valores de MINPRICE y MAXPRICE te ayudará a monitorizar las solicitudes en tiempo real y asegurar que los parámetros se reciben como se esperaba.

Consejos finales

Explora la documentación de TypeORM para descubrir más opciones avanzadas de query.
Mantén siempre tus condiciones tipadas para evitar errores a largo plazo.
Utiliza console.log con moderación y sólo en etapas de depuración para mantener un output limpio en producción.

¡Ahora tienes las herramientas para implementar filtros de precios por rango eficientemente con TypeORM! Sigue explorando y profundizando en herramientas similares para seguir mejorando tus habilidades de desarrollo.

Hanier Morales

student•

Un tip por si actualizan la versión 0.3 de TypeORM.

Cambiar FindConditions a FindOptionsWhere. Según la documentación ha sido renombrado :)

Andres Trujillo

student•

gracias por el dato bro

Ángel David Roque Ayala

student•

Lo que hicimios

// src\products\dtos\products.dtos.ts

@IsOptional()
@IsPositive()
minPrice: number;

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

// src\products\services\products.service.ts

// Cambiamos el servicio
async findAll(params?: FilterProductDto) {
    if (params) {
      const where: FindConditions<Product> = {};
      const { limit, offset } = params;
      const { maxPrice, minPrice } = params;
      
      if (minPrice && maxPrice) {
        where.price = Between(minPrice, maxPrice);
      }

      return this.productRepo.find({
        relations: ['brand'],
        where,
        take: limit,
        skip: offset,
      });
    }

    return this.productRepo.find({
      relations: ['brand'],
    });
  }

Andres Trujillo

student•

gracias por los apuntes bro

Jordan Salazar

student•

A medida que va avanzando el curso quedo más maravillado con todo lo que puedo hacer con Nest JS ofrece.

Andres Trujillo

student•

Me ha parecido una herramienta espectacular y te quita mucha complejidad algoritmica, espero que sigas aprendiendo y puedas conectar la con otras herramientas

Jairo Campos Ruiz

student•

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

student•

Uf bro, interesante la implementación!

Andrés Esteban Rodríguez Jiménez

student•

Filtrando precios con operadores

Vamos a agregar dos filtros más en nuestro DTO de filtros.

**src\products\dtos\products.dtos.ts**:

export class FilterProductsDto {
  // ...

  @IsOptional()
  @IsPositive()
  minPrice: number;

  @IsOptional()
  @IsPositive()
  // esto es posible mientras halla un precio minimo
  @ValidateIf((item) => item.minPrice)
  maxPrice: number;
}

Ahora vamos a nuestro servicio y configuremos estas opciones:

src\products\services\products.service.ts:

// importamos a Between y a FindOptionsWhere
import { In, Repository, Between, FindOptionsWhere } from 'typeorm';

// importamos el DTO
import { CreateProductDto } from '../dtos/product.dto';

@Injectable()
export class ProductsService {
  // ...

  findAll(params?: FilterProductsDto) {
    // declaramos la instrucción where como un objeto vacío
    // será de tipo "FindOptionsWhere" en base a los atributos que tenga un producto
    const where: FindOptionsWhere<Product> = {};
    const { limit, offset, maxPrice, minPrice } = params;

    // preguntamos si los parámetros existen
    if (minPrice && maxPrice) {
      // si existen
      // el precio estara entre el precio minimo al precio máximo
      where.price = Between(minPrice, maxPrice);
    }

    return this.productRepo.find({
      relations: ['brand'],
      where, // añadimos el where a la consulta
      take: limit,
      skip: offset,
    });
  }
}

Y listo, de esta forma agregamos un filtro de precio con operadores que podemos utilizar al momento de realizar una consulta.

Nahuel Soma

student•

En TypeORM 0.3.0, FindConditions es renombrado a FindOptionsWhere. Fuente: https://github.com/typeorm/typeorm/releases/tag/0.3.0

Juan Collado

student•

Validar maxPrice > minPrice con class-validator

Se puede crear un custom decorator para validar que el valor de maxPrice sea mayor al de minPrice con class-validator. Este también va a poder ser reutilizado en otras situaciones en las que pueda ser necesario. https://github.com/typestack/class-validator#custom-validation-decorators

// src/common/IsGreaterThan.validator.ts

import {
  registerDecorator,
  ValidationOptions,
  ValidationArguments,
} from 'class-validator';

export function IsGreaterThan(
  property: string, // Propiedad con la que se va a comparar (minPrice)
  defaultValue: number, // Valor por defecto (en caso de que no haya un minPrice, por ejemplo)
  validationOptions?: ValidationOptions,
) {
  return function (object: unknown, propertyName: string) {
    registerDecorator({
      name: 'isGreaterThan',
      target: object.constructor,
      propertyName,
      constraints: [property],
      options: validationOptions,
      validator: {
        validate(value: any, args: ValidationArguments) {
          const [relatedPropertyName] = args.constraints;
          const relatedValue =
            (args.object as any)[relatedPropertyName] || defaultValue;
          return (
            typeof value === 'number' &&
            typeof relatedValue === 'number' &&
            value > relatedValue
          );
        },
      },
    });
  };
}

// src/products/dtos/products.dtos.ts

import { IsGreaterThan } from 'src/common/IsGreaterThan.validator';
import { IsOptional, isPositive } from 'class-validator';

export class FilterProductDto {
  @IsOptional()
  @IsPositive()
  minPrice: number;

  // En caso de que no haya un minPrice, tomara el valor 0
  @IsOptional()
  @IsGreaterThan('minPrice', 0, {
    message: 'Max price have to be greater than min price.',
  })
  maxPrice: number;
}

Renato Renzo Luna Herrera

student•

Consulta, a ver si pueden ayudarme, estuve buscando en los docs pero no encontré nada.

Que pasaría si digamos tengo una consulta muy compleja, que probablemente se pueda resolver con find-options, pero en este caso tendría que convertirlo, perdería tiempo, o incluso podría no resultar como necesito que funcione (podría).

Como hago para usar SQL directamente con TypeORM sin necesidad de usar las opciones de find?

Nicolas Mendoza

student•

lo mejor es unsar una consulta sql. Es mas rapida si ya conoces sql.

Vanessa Paola Oliveros Padron

student•

QueryBuilder

Andres Trujillo

student•

Quisiera saber la opinión de ustedes sobre un tema en arquitectura:

Teniendo en cuenta que existe Backend y Frontend, que stack debe encargarse de los filtros?
Siguiendo el contexto anterior, que stack debe encargarse de la páginación?

DIEGO MAX NEYRA CORSINO

student•

Un tip para alguien que este buscando porque no arroja error cuando el ValidateIf no se cumple, este lo único que impide es seguir con la validación mas no interrumpir el request.

Fuente: https://stackoverflow.com/questions/66322394/conditionally-failing-validation-using-class-validator

ZANONI ALFREDO SALAS TOBÓN

student•

Es necesario hacer las validaciones a ambos campos o el otro pasa como vacío

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

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

Ricardo Tribaldos Hernández

student•

Sería mejor ajustar la lógica para que puedas trabajar solo con uno o con el otro que es un caso de uso muy usado, además de validar que minPrice < maxPrice en caso de que te pasen ambos parámetros

ZANONI ALFREDO SALAS TOBÓN

student•

Si, luego me toco quitarlo, por que generaba un error creo que con la paginación. :C

Gerardo Ferreyra

student•

Para los que vienen siguiendo el curso con TypeORM 0.3+ FindConditions (where in FindOptions) fue renombrado a FindOptionsWhere.