[feat] Modelo de condicional profundo en consultas

[wrsbyte]

Hola @CodelyTV, Wilmer desde Colombia. Felicidades y gracias por todas las contribuciones al desarrollo de software y la comunidad en español 🥳.

[Problema] Entiendo que el modelo Criteria se propone como una generalización de consultas complejas a través de REST API. Muchos de los frontends que requieren este tipo de consultas requieren concatenar condiciones más profundas que permitan un filtrado preciso.

Aquí un ejemplo del frontal de odoo v15.

[Propuesta] Un modelado de Filtro recursivo que permita seleccionar la relación entre operaciones (AND, OR).

Dejo esbozo de la idea.

import { FilterField } from "./FilterField";
import { FilterOperator, Operator } from "./FilterOperator";
import { FilterValue } from "./FilterValue";

export type Relation = 'AND' | 'OR';

export class Condition {
    readonly field: FilterField;
    readonly operator: FilterOperator;
    readonly value: FilterValue;

    constructor(field: FilterField, operator: FilterOperator, value: FilterValue) {
        this.field = field;
        this.operator = operator;
        this.value = value;
    }

    static fromPrimitives(field: string, operator: string, value: string): Condition {
        return new Condition(
            new FilterField(field),
            new FilterOperator(Operator[operator as keyof typeof Operator]),
            new FilterValue(value),
        );
    }

    toPrimitives(): FiltersPrimitives {
        return {
            field: this.field.value,
            operator: this.operator.value,
            value: this.value.value,
        };
    }
}

export class Filter {
    readonly relation: Relation;
    readonly filters: Array<Condition | Filter>;

    constructor(relation: Relation, filters: Array<Condition | Filter>) {
        this.relation = relation;
        this.filters = filters;
    }

    static fromPrimitives(relation: Relation, filters: Array<FiltersPrimitives>): Filter {
        return new Filter(
            relation,
            filters.map((filter) => {
                const isConditionFilter = 'field' in filter;
                if (isConditionFilter ) {
                    return Condition.fromPrimitives(filter.field, filter.operator, filter.value);
                }
                
                return Filter.fromPrimitives(filter.relation, filter.filters);
            })
        );
    }

    toPrimitives(): any {
        return {
            relation: this.relation,
            filters: this.filters.map((filter) => {
                eturn filter.toPrimitives();
            }),
        };
    }
}

[wrsbyte]

Ejemplo de uso

const filters = [
   {
      relation: "AND",
      filters: [
          {
              field: "name",
              operator: "=",
              value: "wilmer"
          },
          {
              field: "last_name",
              operator: "=",
              value: "rodriguez"
          },
          {
              relation: "OR",
              filters: [
                  {
                      field: "level",
                      operator: "=",
                      value: "senior"
                  },
                  {
                      field: "level",
                      operator: "=",
                      value: "mid"
                  },
              ],
          }
      ]
   }
];