nestjs-query-mikro-orm 0.0.7 → 0.0.9

package/dist/index.mjs

@@ -5,150 +5,9 @@ import { getAssemblerSerializer } from '@nestjs-query/core/dist/src/assemblers/a
 import { BadRequestException, NotFoundException, MethodNotAllowedException } from '@nestjs/common';
 import { instanceToPlain } from 'class-transformer';
 import merge from 'lodash.merge';
-import { camelCase } from 'camel-case';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var AGG_REGEXP = /(AVG|SUM|COUNT|MAX|MIN|GROUP_BY)_(.*)/;
-var AggregateBuilder = class _AggregateBuilder {
-  static {
-    __name(this, "AggregateBuilder");
-  }
-  static async asyncConvertToAggregateResponse(responsePromise) {
-    const aggResponse = await responsePromise;
-    return this.convertToAggregateResponse(aggResponse);
-  }
-  static getAggregateSelects(query) {
-    return [
-      ...this.getAggregateGroupBySelects(query),
-      ...this.getAggregateFuncSelects(query)
-    ];
-  }
-  static getAggregateGroupBySelects(query) {
-    return (query.groupBy ?? []).map((f) => this.getGroupByAlias(f));
-  }
-  static getAggregateFuncSelects(query) {
-    const aggs = [
-      [
-        "COUNT",
-        query.count
-      ],
-      [
-        "SUM",
-        query.sum
-      ],
-      [
-        "AVG",
-        query.avg
-      ],
-      [
-        "MAX",
-        query.max
-      ],
-      [
-        "MIN",
-        query.min
-      ]
-    ];
-    return aggs.reduce((cols, [func, fields]) => {
-      const aliases = (fields ?? []).map((f) => this.getAggregateAlias(func, f));
-      return [
-        ...cols,
-        ...aliases
-      ];
-    }, []);
-  }
-  static getAggregateAlias(func, field) {
-    return `${func}_${field}`;
-  }
-  static getGroupByAlias(field) {
-    return `GROUP_BY_${field}`;
-  }
-  static convertToAggregateResponse(rawAggregates) {
-    return rawAggregates.map((response) => {
-      return Object.keys(response).reduce((agg, resultField) => {
-        const matchResult = AGG_REGEXP.exec(resultField);
-        if (!matchResult) {
-          throw new Error("Unknown aggregate column encountered.");
-        }
-        const [matchedFunc, matchedFieldName] = matchResult.slice(1);
-        const aggFunc = camelCase(matchedFunc.toLowerCase());
-        const fieldName = matchedFieldName;
-        const aggResult = agg[aggFunc] || {};
-        return {
-          ...agg,
-          [aggFunc]: {
-            ...aggResult,
-            [fieldName]: response[resultField]
-          }
-        };
-      }, {});
-    });
-  }
-  /**
-  * Gets the actual database column name for a property from entity metadata.
-  * @param metadata - the entity metadata
-  * @param propertyName - the property name
-  * @returns the database column name
-  */
-  getColumnName(metadata, propertyName) {
-    const prop = metadata.properties[propertyName];
-    if (prop && prop.fieldNames && prop.fieldNames.length > 0) {
-      return prop.fieldNames[0];
-    }
-    return propertyName;
-  }
-  /**
-  * Builds aggregate SELECT clause for MikroORM QueryBuilder.
-  * @param qb - the MikroORM QueryBuilder
-  * @param aggregate - the aggregates to select.
-  * @param alias - optional alias to use to qualify an identifier
-  */
-  build(qb, aggregate, alias) {
-    const metadata = qb.mainAlias?.metadata;
-    const selects = [
-      ...this.createGroupBySelect(aggregate.groupBy, alias, metadata),
-      ...this.createAggSelect("COUNT", aggregate.count, alias, metadata),
-      ...this.createAggSelect("SUM", aggregate.sum, alias, metadata),
-      ...this.createAggSelect("AVG", aggregate.avg, alias, metadata),
-      ...this.createAggSelect("MAX", aggregate.max, alias, metadata),
-      ...this.createAggSelect("MIN", aggregate.min, alias, metadata)
-    ];
-    if (!selects.length) {
-      throw new BadRequestException("No aggregate fields found.");
-    }
-    selects.forEach(([selectExpr, selectAlias]) => {
-      qb.addSelect(raw(`${selectExpr} as "${selectAlias}"`));
-    });
-    return qb;
-  }
-  createAggSelect(func, fields, alias, metadata) {
-    if (!fields) {
-      return [];
-    }
-    return fields.map((field) => {
-      const columnName = metadata ? this.getColumnName(metadata, field) : field;
-      const col = alias ? `\`${alias}\`.\`${columnName}\`` : `\`${columnName}\``;
-      return [
-        `${func}(${col})`,
-        _AggregateBuilder.getAggregateAlias(func, field)
-      ];
-    });
-  }
-  createGroupBySelect(fields, alias, metadata) {
-    if (!fields) {
-      return [];
-    }
-    return fields.map((field) => {
-      const columnName = metadata ? this.getColumnName(metadata, field) : field;
-      const col = alias ? `\`${alias}\`.\`${columnName}\`` : `\`${columnName}\``;
-      return [
-        `${col}`,
-        _AggregateBuilder.getGroupByAlias(field)
-      ];
-    });
-  }
-};
 
 // src/lib/query/where.builder.ts
 var WhereBuilder = class {
@@ -388,81 +247,50 @@ var FilterQueryBuilder = class {
   }
   repo;
   whereBuilder;
-  aggregateBuilder;
-  constructor(repo, whereBuilder = new WhereBuilder(), aggregateBuilder = new AggregateBuilder()) {
+  constructor(repo, whereBuilder = new WhereBuilder()) {
     this.repo = repo;
     this.whereBuilder = whereBuilder;
-    this.aggregateBuilder = aggregateBuilder;
   }
   /**
-  * Create a MikroORM QueryBuilder with `WHERE`, `ORDER BY` and `LIMIT/OFFSET` clauses.
-  *
-  * @param query - the query to apply.
+  * NOTE: QueryBuilder-specific helpers removed; use `buildFindOptions` to
+  * produce a filter and options for `em.find`/`repo.find`.
   */
-  select(query) {
-    const alias = this.getEntityAlias();
-    const qb = this.createQueryBuilder(alias);
-    this.applyFilter(qb, query.filter, alias);
-    this.applySorting(qb, query.sorting, alias);
-    this.applyPaging(qb, query.paging);
-    return qb;
-  }
-  selectById(id, query) {
-    const alias = this.getEntityAlias();
-    const qb = this.createQueryBuilder(alias);
-    const metadata = this.repo.getEntityManager().getMetadata().get(this.repo.getEntityName());
-    const primaryKey = metadata.primaryKeys[0];
-    if (Array.isArray(id)) {
-      qb.where({
-        [primaryKey]: {
-          $in: id
-        }
-      });
-    } else {
-      qb.where({
-        [primaryKey]: id
-      });
-    }
-    this.applyFilter(qb, query.filter, alias);
-    this.applySorting(qb, query.sorting, alias);
-    this.applyPaging(qb, query.paging);
-    return qb;
-  }
-  aggregate(query, aggregate) {
-    const alias = this.getEntityAlias();
-    const qb = this.createQueryBuilder(alias);
-    this.applyAggregate(qb, aggregate, alias);
-    this.applyFilter(qb, query.filter, alias);
-    this.applyAggregateSorting(qb, aggregate.groupBy, alias);
-    this.applyGroupBy(qb, aggregate.groupBy, alias);
-    return qb;
-  }
   /**
-  * Applies paging to a MikroORM query builder
-  * @param qb - the MikroORM QueryBuilder
-  * @param paging - the Paging options.
+  * Build a filter query and find options suitable for `em.find`/`repo.find` calls.
+  * This keeps usage DB-agnostic by returning plain filter objects and options
+  * instead of driver-specific QueryBuilder instances.
   */
-  applyPaging(qb, paging) {
-    if (!paging) {
-      return qb;
-    }
-    if (paging.limit !== void 0) {
-      qb.limit(paging.limit);
-    }
-    if (paging.offset !== void 0) {
-      qb.offset(paging.offset);
+  buildFindOptions(query) {
+    const result = {};
+    if (query.filter) {
+      const mikroOrmFilter = this.whereBuilder.build(query.filter);
+      result.filterQuery = mikroOrmFilter;
+    }
+    const paging = query.paging;
+    const sorting = query.sorting;
+    if (paging && (paging.limit !== void 0 || paging.offset !== void 0) || sorting && sorting.length) {
+      const options = {};
+      if (paging) {
+        if (paging.limit !== void 0) options.limit = paging.limit;
+        if (paging.offset !== void 0) options.offset = paging.offset;
+      }
+      if (sorting && sorting.length > 0) {
+        const orderBy = sorting.reduce((acc, { field, direction, nulls }) => {
+          const order = direction === "ASC" ? "asc" : "desc";
+          let orderValue = order;
+          if (nulls) {
+            orderValue = `${order} ${nulls.toLowerCase().replace("_", " ")}`;
+          }
+          return {
+            ...acc,
+            [field]: orderValue
+          };
+        }, {});
+        options.orderBy = orderBy;
+      }
+      result.options = options;
     }
-    return qb;
-  }
-  /**
-  * Applies the aggregate selects from a Query to a MikroORM QueryBuilder.
-  *
-  * @param qb - the MikroORM QueryBuilder.
-  * @param aggregate - the aggregates to select.
-  * @param alias - optional alias to use to qualify an identifier
-  */
-  applyAggregate(qb, aggregate, alias) {
-    return this.aggregateBuilder.build(qb, aggregate, alias);
+    return result;
   }
   /**
   * Applies the filter from a Query to a MikroORM QueryBuilder.
@@ -524,7 +352,7 @@ var FilterQueryBuilder = class {
   * Create a MikroORM QueryBuilder.
   */
   createQueryBuilder(alias) {
-    return this.repo.createQueryBuilder(alias);
+    return this.repo.createQueryBuilder?.(alias);
   }
   /**
   * Gets the entity alias based on the entity name.
@@ -613,10 +441,10 @@ var FilterQueryBuilder = class {
   }
 };
 
-// src/lib/query/sql-comparison.builder.ts
-var SQLComparisonBuilder = class {
+// src/lib/query/comparison.builder.ts
+var ComparisonBuilder = class {
   static {
-    __name(this, "SQLComparisonBuilder");
+    __name(this, "ComparisonBuilder");
   }
   /**
   * Maps a comparison operator to MikroORM filter format.
@@ -826,68 +654,162 @@ var RelationQueryBuilder = class {
     this.filterQueryBuilder = new FilterQueryBuilder(relationRepo);
   }
   /**
-  * Builds and returns a QueryBuilder for selecting relations without executing it.
-  * This is useful for testing or when you need to inspect/modify the query before execution.
+  * Executes a relation select using `em.find` so the implementation is database-agnostic.
   */
-  select(entity, query) {
+  async selectAndExecute(entity, query) {
     const relationMeta = this.getRelationMeta();
     const em = this.repo.getEntityManager();
-    const relationEntityName = relationMeta.type;
-    const entityMeta = em.getMetadata().get(this.repo.getEntityName());
-    const entityPrimaryKey = entityMeta.primaryKeys[0];
-    const entityId = entity[entityPrimaryKey];
-    let qb = em.createQueryBuilder(relationEntityName);
-    if (relationMeta.kind === "1:1" && relationMeta.owner && relationMeta.inversedBy) {
-      const fkFieldName = relationMeta.joinColumns?.[0] || relationMeta.fieldNames?.[0];
-      const fkValue = fkFieldName ? entity[fkFieldName] : void 0;
-      if (fkValue === void 0) {
-        const parentAlias = "parent";
-        const relationAlias = qb.alias;
-        qb = qb.leftJoin(`${relationAlias}.${relationMeta.inversedBy}`, parentAlias).where({
-          [`${parentAlias}.${entityPrimaryKey}`]: entityId
-        });
-        qb = this.filterQueryBuilder.applyFilter(qb, query.filter);
-        qb = this.filterQueryBuilder.applyPaging(qb, query.paging);
-        qb = this.filterQueryBuilder.applySorting(qb, query.sorting);
-        return qb;
-      }
-    }
-    const whereCondition = this.buildWhereCondition(entity, relationMeta);
-    qb = qb.where(whereCondition);
-    qb = this.filterQueryBuilder.applyFilter(qb, query.filter);
-    qb = this.filterQueryBuilder.applyPaging(qb, query.paging);
-    qb = this.filterQueryBuilder.applySorting(qb, query.sorting);
-    return qb;
-  }
-  /**
-  * Executes the select query and returns the results.
-  */
-  async selectAndExecute(entity, query) {
-    const qb = this.select(entity, query);
-    return qb.getResultList();
+    const RelationEntity = relationMeta.type;
+    const baseWhere = this.buildWhereCondition(entity, relationMeta);
+    const { filterQuery, options } = this.filterQueryBuilder.buildFindOptions(query);
+    const finalWhere = filterQuery ? {
+      $and: [
+        baseWhere,
+        filterQuery
+      ]
+    } : baseWhere;
+    const findOptions = {};
+    if (options?.orderBy) findOptions.orderBy = options.orderBy;
+    if (options?.limit !== void 0) findOptions.limit = options.limit;
+    if (options?.offset !== void 0) findOptions.offset = options.offset;
+    return await em.find(RelationEntity, finalWhere, findOptions);
   }
   async count(entity, query) {
     const relationMeta = this.getRelationMeta();
     const em = this.repo.getEntityManager();
-    const relationEntityName = relationMeta.type;
-    let qb = em.createQueryBuilder(relationEntityName);
-    const whereCondition = this.buildWhereCondition(entity, relationMeta);
-    qb = qb.where(whereCondition);
-    qb = this.filterQueryBuilder.applyFilter(qb, query.filter);
-    return qb.getCount();
+    const RelationEntity = relationMeta.type;
+    const baseWhere = this.buildWhereCondition(entity, relationMeta);
+    const { filterQuery } = this.filterQueryBuilder.buildFindOptions(query);
+    const finalWhere = filterQuery ? {
+      $and: [
+        baseWhere,
+        filterQuery
+      ]
+    } : baseWhere;
+    return em.count(RelationEntity, finalWhere);
   }
   async aggregate(entity, query, aggregateQuery) {
     const relationMeta = this.getRelationMeta();
     const em = this.repo.getEntityManager();
-    const relationEntityName = relationMeta.type;
-    let qb = em.createQueryBuilder(relationEntityName);
-    const whereCondition = this.buildWhereCondition(entity, relationMeta);
-    qb = qb.where(whereCondition);
-    qb = this.filterQueryBuilder.applyAggregate(qb, aggregateQuery);
-    qb = this.filterQueryBuilder.applyFilter(qb, query.filter);
-    qb = this.filterQueryBuilder.applyAggregateSorting(qb, aggregateQuery.groupBy);
-    qb = this.filterQueryBuilder.applyGroupBy(qb, aggregateQuery.groupBy);
-    return qb.execute();
+    const RelationEntity = relationMeta.type;
+    const baseWhere = this.buildWhereCondition(entity, relationMeta);
+    const { filterQuery } = this.filterQueryBuilder.buildFindOptions(query);
+    const finalWhere = filterQuery ? {
+      $and: [
+        baseWhere,
+        filterQuery
+      ]
+    } : baseWhere;
+    const rows = await em.find(RelationEntity, finalWhere);
+    const aggs = aggregateQuery;
+    const groupBy = aggs.groupBy ?? [];
+    const makeAggKey = /* @__PURE__ */ __name((func, field) => `${func}_${field}`, "makeAggKey");
+    const makeGroupKey = /* @__PURE__ */ __name((field) => `GROUP_BY_${field}`, "makeGroupKey");
+    const records = [];
+    const isNumeric = /* @__PURE__ */ __name((v) => typeof v === "number" || v instanceof Date, "isNumeric");
+    if (groupBy.length === 0) {
+      const out = {};
+      const computeField = /* @__PURE__ */ __name((fn, field) => {
+        const values = rows.map((r) => r[field]).filter((v) => v !== void 0 && v !== null);
+        if (fn === "COUNT") {
+          out[makeAggKey("COUNT", field)] = values.length;
+          return;
+        }
+        if (values.length === 0) {
+          out[makeAggKey(fn, field)] = null;
+          return;
+        }
+        if (fn === "SUM" || fn === "AVG") {
+          const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v)).filter((n) => !Number.isNaN(n));
+          const sum = nums.reduce((s, v) => s + v, 0);
+          out[makeAggKey(fn, field)] = fn === "SUM" ? sum : nums.length ? sum / nums.length : null;
+          return;
+        }
+        if (fn === "MAX") {
+          if (values.every(isNumeric)) {
+            const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v));
+            out[makeAggKey("MAX", field)] = Math.max(...nums);
+          } else {
+            out[makeAggKey("MAX", field)] = values.reduce((a, b) => String(a) > String(b) ? a : b);
+          }
+          return;
+        }
+        if (fn === "MIN") {
+          if (values.every(isNumeric)) {
+            const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v));
+            out[makeAggKey("MIN", field)] = Math.min(...nums);
+          } else {
+            out[makeAggKey("MIN", field)] = values.reduce((a, b) => String(a) < String(b) ? a : b);
+          }
+          return;
+        }
+      }, "computeField");
+      (aggs.count ?? []).forEach((f) => computeField("COUNT", String(f)));
+      (aggs.sum ?? []).forEach((f) => computeField("SUM", String(f)));
+      (aggs.avg ?? []).forEach((f) => computeField("AVG", String(f)));
+      (aggs.max ?? []).forEach((f) => computeField("MAX", String(f)));
+      (aggs.min ?? []).forEach((f) => computeField("MIN", String(f)));
+      records.push(out);
+    } else {
+      const groups = /* @__PURE__ */ new Map();
+      rows.forEach((r) => {
+        const keyParts = groupBy.map((g) => JSON.stringify(r[String(g)]));
+        const key = keyParts.join("|");
+        const arr = groups.get(key) ?? [];
+        arr.push(r);
+        groups.set(key, arr);
+      });
+      groups.forEach((groupRows, key) => {
+        const parts = key.split("|").map((p) => JSON.parse(p));
+        const out = {};
+        groupBy.forEach((g, i) => {
+          const val = parts[i];
+          out[makeGroupKey(String(g))] = typeof val === "boolean" ? val ? 1 : 0 : val;
+        });
+        const computeField = /* @__PURE__ */ __name((fn, field) => {
+          const values = groupRows.map((r) => r[field]).filter((v) => v !== void 0 && v !== null);
+          if (fn === "COUNT") {
+            out[makeAggKey("COUNT", field)] = values.length;
+            return;
+          }
+          if (values.length === 0) {
+            out[makeAggKey(fn, field)] = null;
+            return;
+          }
+          if (fn === "SUM" || fn === "AVG") {
+            const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v)).filter((n) => !Number.isNaN(n));
+            const sum = nums.reduce((s, v) => s + v, 0);
+            out[makeAggKey(fn, field)] = fn === "SUM" ? sum : nums.length ? sum / nums.length : null;
+            return;
+          }
+          if (fn === "MAX") {
+            if (values.every(isNumeric)) {
+              const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v));
+              out[makeAggKey("MAX", field)] = Math.max(...nums);
+            } else {
+              out[makeAggKey("MAX", field)] = values.reduce((a, b) => String(a) > String(b) ? a : b);
+            }
+            return;
+          }
+          if (fn === "MIN") {
+            if (values.every(isNumeric)) {
+              const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v));
+              out[makeAggKey("MIN", field)] = Math.min(...nums);
+            } else {
+              out[makeAggKey("MIN", field)] = values.reduce((a, b) => String(a) < String(b) ? a : b);
+            }
+            return;
+          }
+        }, "computeField");
+        (aggs.count ?? []).forEach((f) => computeField("COUNT", String(f)));
+        (aggs.sum ?? []).forEach((f) => computeField("SUM", String(f)));
+        (aggs.avg ?? []).forEach((f) => computeField("AVG", String(f)));
+        (aggs.max ?? []).forEach((f) => computeField("MAX", String(f)));
+        (aggs.min ?? []).forEach((f) => computeField("MIN", String(f)));
+        records.push(out);
+      });
+    }
+    return records;
   }
   buildWhereCondition(entity, relationMeta) {
     const em = this.repo.getEntityManager();
@@ -1005,6 +927,217 @@ var RelationQueryBuilder = class {
     });
   }
 };
+var AGG_REGEXP = /^(AVG|SUM|COUNT|MAX|MIN|GROUP_BY|group_by|groupBy|avg|sum|count|max|min)_(.*)$/i;
+var AggregateBuilder = class _AggregateBuilder {
+  static {
+    __name(this, "AggregateBuilder");
+  }
+  static buildSelectExpressions(aggregate, alias) {
+    const aggs = [
+      [
+        "COUNT",
+        aggregate.count
+      ],
+      [
+        "SUM",
+        aggregate.sum
+      ],
+      [
+        "AVG",
+        aggregate.avg
+      ],
+      [
+        "MAX",
+        aggregate.max
+      ],
+      [
+        "MIN",
+        aggregate.min
+      ]
+    ];
+    const groupBySelects = (aggregate.groupBy ?? []).map((f) => {
+      const col = alias ? `\`${alias}\`.\`${String(f)}\`` : `\`${String(f)}\``;
+      return [
+        col,
+        _AggregateBuilder.getGroupByAlias(f)
+      ];
+    });
+    const funcSelects = [];
+    aggs.forEach(([func, fields]) => {
+      const aliases = (fields ?? []).map((f) => {
+        const col = alias ? `\`${alias}\`.\`${String(f)}\`` : `\`${String(f)}\``;
+        return [
+          `${func}(${col})`,
+          _AggregateBuilder.getAggregateAlias(func, f)
+        ];
+      });
+      funcSelects.push(...aliases);
+    });
+    const selects = [
+      ...groupBySelects,
+      ...funcSelects
+    ];
+    if (!selects.length) {
+      throw new BadRequestException("No aggregate fields found.");
+    }
+    return selects;
+  }
+  static async asyncConvertToAggregateResponse(responsePromise) {
+    const aggResponse = await responsePromise;
+    return this.convertToAggregateResponse(aggResponse);
+  }
+  static getAggregateSelects(query) {
+    return [
+      ...this.getAggregateGroupBySelects(query),
+      ...this.getAggregateFuncSelects(query)
+    ];
+  }
+  static getAggregateGroupBySelects(query) {
+    return (query.groupBy ?? []).map((f) => this.getGroupByAlias(f));
+  }
+  static getAggregateFuncSelects(query) {
+    const aggs = [
+      [
+        "COUNT",
+        query.count
+      ],
+      [
+        "SUM",
+        query.sum
+      ],
+      [
+        "AVG",
+        query.avg
+      ],
+      [
+        "MAX",
+        query.max
+      ],
+      [
+        "MIN",
+        query.min
+      ]
+    ];
+    return aggs.reduce((cols, [func, fields]) => {
+      const aliases = (fields ?? []).map((f) => this.getAggregateAlias(func, f));
+      return [
+        ...cols,
+        ...aliases
+      ];
+    }, []);
+  }
+  static getAggregateAlias(func, field) {
+    return `${func}_${field}`;
+  }
+  static getGroupByAlias(field) {
+    return `GROUP_BY_${field}`;
+  }
+  static convertToAggregateResponse(rawAggregates) {
+    return rawAggregates.map((response) => {
+      const agg = {};
+      if (response._id && typeof response._id === "object") {
+        const idObj = response._id;
+        Object.keys(idObj).forEach((k) => {
+          const m = /^(?:GROUP_BY|group_by|groupBy)_(.*)$/i.exec(k);
+          if (m) {
+            const field = m[1];
+            agg.groupBy = {
+              ...agg.groupBy,
+              [field]: idObj[k]
+            };
+          }
+        });
+      }
+      Object.keys(response).forEach((resultField) => {
+        if (resultField === "_id") return;
+        const matchResult = AGG_REGEXP.exec(resultField);
+        if (!matchResult) {
+          throw new Error("Unknown aggregate column encountered.");
+        }
+        const matchedFunc = matchResult[1];
+        const matchedFieldName = matchResult[2];
+        const funcKey = matchedFunc.toLowerCase();
+        const aggFunc = funcKey === "group_by" || funcKey === "groupby" ? "groupBy" : funcKey;
+        if (aggFunc === "groupBy") {
+          agg.groupBy = {
+            ...agg.groupBy,
+            [matchedFieldName]: response[resultField]
+          };
+          return;
+        }
+        const fieldName = matchedFieldName;
+        agg[aggFunc] = {
+          ...agg[aggFunc],
+          [fieldName]: response[resultField]
+        };
+      });
+      return agg;
+    });
+  }
+  /**
+  * Gets the actual database column name for a property from entity metadata.
+  * @param metadata - the entity metadata
+  * @param propertyName - the property name
+  * @returns the database column name
+  */
+  getColumnName(metadata, propertyName) {
+    const prop = metadata.properties[propertyName];
+    if (prop && prop.fieldNames && prop.fieldNames.length > 0) {
+      return prop.fieldNames[0];
+    }
+    return propertyName;
+  }
+  /**
+  * Builds aggregate SELECT clause for MikroORM QueryBuilder.
+  * @param qb - the MikroORM QueryBuilder
+  * @param aggregate - the aggregates to select.
+  * @param alias - optional alias to use to qualify an identifier
+  */
+  build(qb, aggregate, alias) {
+    const metadata = qb.mainAlias?.metadata;
+    const selects = [
+      ...this.createGroupBySelect(aggregate.groupBy, alias, metadata),
+      ...this.createAggSelect("COUNT", aggregate.count, alias, metadata),
+      ...this.createAggSelect("SUM", aggregate.sum, alias, metadata),
+      ...this.createAggSelect("AVG", aggregate.avg, alias, metadata),
+      ...this.createAggSelect("MAX", aggregate.max, alias, metadata),
+      ...this.createAggSelect("MIN", aggregate.min, alias, metadata)
+    ];
+    if (!selects.length) {
+      throw new BadRequestException("No aggregate fields found.");
+    }
+    selects.forEach(([selectExpr, selectAlias]) => {
+      qb.addSelect(raw(`${selectExpr} as "${selectAlias}"`));
+    });
+    return qb;
+  }
+  createAggSelect(func, fields, alias, metadata) {
+    if (!fields) {
+      return [];
+    }
+    return fields.map((field) => {
+      const columnName = metadata ? this.getColumnName(metadata, field) : field;
+      const col = alias ? `\`${alias}\`.\`${columnName}\`` : `\`${columnName}\``;
+      return [
+        `${func}(${col})`,
+        _AggregateBuilder.getAggregateAlias(func, field)
+      ];
+    });
+  }
+  createGroupBySelect(fields, alias, metadata) {
+    if (!fields) {
+      return [];
+    }
+    return fields.map((field) => {
+      const columnName = metadata ? this.getColumnName(metadata, field) : field;
+      const col = alias ? `\`${alias}\`.\`${columnName}\`` : `\`${columnName}\``;
+      return [
+        `${col}`,
+        _AggregateBuilder.getGroupByAlias(field)
+      ];
+    });
+  }
+};
 var RelationQueryService = class {
   static {
     __name(this, "RelationQueryService");
@@ -1372,24 +1505,169 @@ var MikroOrmQueryService = class extends RelationQueryService {
   * @param query - The Query used to filter, page, and sort rows.
   */
   async query(query) {
-    const qb = this.filterQueryBuilder.select(query);
-    await qb.applyFilters();
-    return qb.getResultList();
+    const { filterQuery, options } = this.filterQueryBuilder.buildFindOptions(query);
+    const em = this.repo.getEntityManager();
+    let where = filterQuery;
+    if (this.useSoftDelete) {
+      const deletedFilter = {
+        deletedAt: null
+      };
+      where = where ? {
+        $and: [
+          where,
+          deletedFilter
+        ]
+      } : deletedFilter;
+    }
+    return em.find(this.EntityClass, where ?? {}, options);
   }
   async aggregate(filter, aggregate) {
-    const qb = this.filterQueryBuilder.aggregate({
+    const { filterQuery } = this.filterQueryBuilder.buildFindOptions({
       filter
-    }, aggregate);
-    await qb.applyFilters();
-    const rawResults = await qb.execute();
-    return AggregateBuilder.convertToAggregateResponse(rawResults);
+    });
+    const em = this.repo.getEntityManager();
+    let where = filterQuery;
+    if (this.useSoftDelete) {
+      const deletedFilter = {
+        deletedAt: null
+      };
+      where = where ? {
+        $and: [
+          where,
+          deletedFilter
+        ]
+      } : deletedFilter;
+    }
+    const rows = await em.find(this.EntityClass, where ?? {});
+    const aggs = aggregate;
+    const groupBy = aggs.groupBy ?? [];
+    const records = [];
+    const makeAggKey = /* @__PURE__ */ __name((func, field) => `${func}_${field}`, "makeAggKey");
+    const makeGroupKey = /* @__PURE__ */ __name((field) => `GROUP_BY_${field}`, "makeGroupKey");
+    const isNumeric = /* @__PURE__ */ __name((v) => typeof v === "number" || v instanceof Date, "isNumeric");
+    if (groupBy.length === 0) {
+      const out = {};
+      const computeField = /* @__PURE__ */ __name((fn, field) => {
+        const values = rows.map((r) => r[field]).filter((v) => v !== void 0 && v !== null);
+        if (fn === "COUNT") {
+          out[makeAggKey("COUNT", field)] = values.length;
+          return;
+        }
+        if (values.length === 0) {
+          out[makeAggKey(fn, field)] = null;
+          return;
+        }
+        if (fn === "SUM" || fn === "AVG") {
+          const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v)).filter((n) => !Number.isNaN(n));
+          const sum = nums.reduce((s, v) => s + v, 0);
+          out[makeAggKey(fn, field)] = fn === "SUM" ? sum : nums.length ? sum / nums.length : null;
+          return;
+        }
+        if (fn === "MAX") {
+          if (values.every(isNumeric)) {
+            const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v));
+            out[makeAggKey("MAX", field)] = Math.max(...nums);
+          } else {
+            out[makeAggKey("MAX", field)] = values.reduce((a, b) => String(a) > String(b) ? a : b);
+          }
+          return;
+        }
+        if (fn === "MIN") {
+          if (values.every(isNumeric)) {
+            const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v));
+            out[makeAggKey("MIN", field)] = Math.min(...nums);
+          } else {
+            out[makeAggKey("MIN", field)] = values.reduce((a, b) => String(a) < String(b) ? a : b);
+          }
+          return;
+        }
+      }, "computeField");
+      (aggs.count ?? []).forEach((f) => computeField("COUNT", String(f)));
+      (aggs.sum ?? []).forEach((f) => computeField("SUM", String(f)));
+      (aggs.avg ?? []).forEach((f) => computeField("AVG", String(f)));
+      (aggs.max ?? []).forEach((f) => computeField("MAX", String(f)));
+      (aggs.min ?? []).forEach((f) => computeField("MIN", String(f)));
+      records.push(out);
+    } else {
+      const groups = /* @__PURE__ */ new Map();
+      rows.forEach((r) => {
+        const key = groupBy.map((g) => JSON.stringify(r[String(g)])).join("|");
+        const arr = groups.get(key) ?? [];
+        arr.push(r);
+        groups.set(key, arr);
+      });
+      groups.forEach((groupRows, key) => {
+        const parts = key.split("|").map((p) => JSON.parse(p));
+        const out = {};
+        groupBy.forEach((g, i) => {
+          const val = parts[i];
+          out[makeGroupKey(String(g))] = typeof val === "boolean" ? val ? 1 : 0 : val;
+        });
+        const computeField = /* @__PURE__ */ __name((fn, field) => {
+          const values = groupRows.map((r) => r[field]).filter((v) => v !== void 0 && v !== null);
+          if (fn === "COUNT") {
+            out[makeAggKey("COUNT", field)] = values.length;
+            return;
+          }
+          if (values.length === 0) {
+            out[makeAggKey(fn, field)] = null;
+            return;
+          }
+          if (fn === "SUM" || fn === "AVG") {
+            const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v)).filter((n) => !Number.isNaN(n));
+            const sum = nums.reduce((s, v) => s + v, 0);
+            out[makeAggKey(fn, field)] = fn === "SUM" ? sum : nums.length ? sum / nums.length : null;
+            return;
+          }
+          if (fn === "MAX") {
+            if (values.every(isNumeric)) {
+              const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v));
+              out[makeAggKey("MAX", field)] = Math.max(...nums);
+            } else {
+              out[makeAggKey("MAX", field)] = values.reduce((a, b) => String(a) > String(b) ? a : b);
+            }
+            return;
+          }
+          if (fn === "MIN") {
+            if (values.every(isNumeric)) {
+              const nums = values.map((v) => v instanceof Date ? v.getTime() : Number(v));
+              out[makeAggKey("MIN", field)] = Math.min(...nums);
+            } else {
+              out[makeAggKey("MIN", field)] = values.reduce((a, b) => String(a) < String(b) ? a : b);
+            }
+            return;
+          }
+        }, "computeField");
+        (aggs.count ?? []).forEach((f) => computeField("COUNT", String(f)));
+        (aggs.sum ?? []).forEach((f) => computeField("SUM", String(f)));
+        (aggs.avg ?? []).forEach((f) => computeField("AVG", String(f)));
+        (aggs.max ?? []).forEach((f) => computeField("MAX", String(f)));
+        (aggs.min ?? []).forEach((f) => computeField("MIN", String(f)));
+        records.push(out);
+      });
+    }
+    return records.map((r) => AggregateBuilder.convertToAggregateResponse([
+      r
+    ])[0]);
   }
   async count(filter) {
-    const qb = this.filterQueryBuilder.select({
+    const { filterQuery } = this.filterQueryBuilder.buildFindOptions({
       filter
     });
-    await qb.applyFilters();
-    return qb.getCount();
+    const em = this.repo.getEntityManager();
+    let where = filterQuery;
+    if (this.useSoftDelete) {
+      const deletedFilter = {
+        deletedAt: null
+      };
+      where = where ? {
+        $and: [
+          where,
+          deletedFilter
+        ]
+      } : deletedFilter;
+    }
+    return em.count(this.EntityClass, where ?? {});
   }
   /**
   * Find an entity by it's `id`.
@@ -1401,10 +1679,33 @@ var MikroOrmQueryService = class extends RelationQueryService {
   * @param id - The id of the record to find.
   */
   async findById(id, opts) {
-    const qb = this.filterQueryBuilder.selectById(id, opts ?? {});
-    await qb.applyFilters();
-    const result = await qb.getSingleResult();
-    return result ?? void 0;
+    const metadata = this.em.getMetadata().get(this.repo.getEntityName());
+    const primaryKey = metadata.primaryKeys[0];
+    let where = {
+      [primaryKey]: id
+    };
+    if (opts?.filter) {
+      const whereBuilder = new WhereBuilder();
+      const additional = whereBuilder.build(opts.filter);
+      where = {
+        $and: [
+          where,
+          additional
+        ]
+      };
+    }
+    if (this.useSoftDelete) {
+      where = {
+        $and: [
+          where,
+          {
+            deletedAt: null
+          }
+        ]
+      };
+    }
+    const entity = await this.em.findOne(this.EntityClass, where);
+    return entity ?? void 0;
   }
   /**
   * Gets an entity by it's `id`. If the entity is not found a rejected promise is returned.
@@ -1469,9 +1770,10 @@ var MikroOrmQueryService = class extends RelationQueryService {
   * @param opts - Additional options.
   */
   async updateOne(id, update, opts) {
-    this.ensureIdIsNotPresent(update);
+    const dateWithClearUndefined = Object.fromEntries(Object.entries(update).filter(([, value]) => value !== void 0));
+    this.ensureIdIsNotPresent(dateWithClearUndefined);
     const entity = await this.getById(id, opts);
-    wrap(entity).assign(update);
+    wrap(entity).assign(dateWithClearUndefined);
     await this.repo.getEntityManager().flush();
     return entity;
   }
@@ -1712,6 +2014,6 @@ var NestjsQueryMikroOrmModule = class _NestjsQueryMikroOrmModule {
   }
 };
 
-export { AggregateBuilder, FilterQueryBuilder, MikroOrmQueryService, NestjsQueryMikroOrmModule, RelationQueryBuilder, RelationQueryService, SQLComparisonBuilder, WhereBuilder, createMikroOrmQueryServiceProviders };
+export { AggregateBuilder, ComparisonBuilder, FilterQueryBuilder, MikroOrmQueryService, NestjsQueryMikroOrmModule, RelationQueryBuilder, RelationQueryService, WhereBuilder, createMikroOrmQueryServiceProviders };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map