fix(select-buildwhere): support More/LessThanOrEqual for relations

Tweak `buildWhere()` to recognise more find operators and output
the SQL equivalent

- Recognise `moreThanOrEqual` and `lessThanOrEqual`, in addition to
  `moreThan` and `lessThan`
- Dedicate an if block to `moreThanOrEqual` and `lessThanOrEqual`,
  replicating most of the `moreThan`/`lessThan` equivalents, for
  reading simplicity

src/query-builder/SelectQueryBuilder.ts

@@ -4412,6 +4412,97 @@ export class SelectQueryBuilder<Entity extends ObjectLiteral>
                                     " " +
                                     parseInt(where[key].value),
                             )
+                        } else if (
+                            where[key].type === "moreThanOrEqual" ||
+                            where[key].type === "lessThanOrEqual"
+                        ) {
+                            const sqlOperator =
+                                where[key].type === "moreThan" ? ">=" : "<="
+                            // basically relation count functionality
+                            const qb: QueryBuilder<any> = this.subQuery()
+                            if (relation.isManyToManyOwner) {
+                                qb.select("COUNT(*)")
+                                    .from(
+                                        relation.joinTableName,
+                                        relation.joinTableName,
+                                    )
+                                    .where(
+                                        relation.joinColumns
+                                            .map((column) => {
+                                                return `${
+                                                    relation.joinTableName
+                                                }.${
+                                                    column.propertyName
+                                                } = ${alias}.${
+                                                    column.referencedColumn!
+                                                        .propertyName
+                                                }`
+                                            })
+                                            .join(" AND "),
+                                    )
+                            } else if (relation.isManyToManyNotOwner) {
+                                qb.select("COUNT(*)")
+                                    .from(
+                                        relation.inverseRelation!.joinTableName,
+                                        relation.inverseRelation!.joinTableName,
+                                    )
+                                    .where(
+                                        relation
+                                            .inverseRelation!.inverseJoinColumns.map(
+                                                (column) => {
+                                                    return `${
+                                                        relation.inverseRelation!
+                                                            .joinTableName
+                                                    }.${
+                                                        column.propertyName
+                                                    } = ${alias}.${
+                                                        column.referencedColumn!
+                                                            .propertyName
+                                                    }`
+                                                },
+                                            )
+                                            .join(" AND "),
+                                    )
+                            } else if (relation.isOneToMany) {
+                                qb.select("COUNT(*)")
+                                    .from(
+                                        relation.inverseEntityMetadata.target,
+                                        relation.inverseEntityMetadata
+                                            .tableName,
+                                    )
+                                    .where(
+                                        relation
+                                            .inverseRelation!.joinColumns.map(
+                                                (column) => {
+                                                    return `${
+                                                        relation
+                                                            .inverseEntityMetadata
+                                                            .tableName
+                                                    }.${
+                                                        column.propertyName
+                                                    } = ${alias}.${
+                                                        column.referencedColumn!
+                                                            .propertyName
+                                                    }`
+                                                },
+                                            )
+                                            .join(" AND "),
+                                    )
+                            } else {
+                                throw new Error(
+                                    `This relation isn't supported by given find operator`,
+                                )
+                            }
+                            // this
+                            //     .addSelect(qb.getSql(), relation.propertyAliasName + "_cnt")
+                            //     .andWhere(this.escape(relation.propertyAliasName + "_cnt") + " " + sqlOperator + " " + parseInt(where[key].value));
+                            this.andWhere(
+                                qb.getSql() +
+                                    " " +
+                                    sqlOperator +
+                                    " " +
+                                    parseInt(where[key].value),
+                            )
                         } else {
                             if (
                                 relation.isManyToOne ||