nestjs-query-mikro-orm 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -1,92 +1,67 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  AggregateBuilder: () => AggregateBuilder,
-  FilterQueryBuilder: () => FilterQueryBuilder,
-  MikroOrmQueryService: () => MikroOrmQueryService,
-  NestjsQueryMikroOrmModule: () => NestjsQueryMikroOrmModule,
-  RelationQueryBuilder: () => RelationQueryBuilder,
-  RelationQueryService: () => RelationQueryService,
-  SQLComparisonBuilder: () => SQLComparisonBuilder,
-  WhereBuilder: () => WhereBuilder,
-  createMikroOrmQueryServiceProviders: () => createMikroOrmQueryServiceProviders
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/lib/nest-query-mikro-orm.module.ts
-var import_nestjs2 = require("@mikro-orm/nestjs");
+'use strict';
 
-// src/lib/providers.ts
-var import_nestjs = require("@mikro-orm/nestjs");
-var import_core7 = require("@nestjs-query/core");
+var nestjs = require('@mikro-orm/nestjs');
+var core$1 = require('@nestjs-query/core');
+var core = require('@mikro-orm/core');
+var assembler_serializer = require('@nestjs-query/core/dist/src/assemblers/assembler.serializer');
+var common = require('@nestjs/common');
+var classTransformer = require('class-transformer');
+var merge = require('lodash.merge');
+var camelCase = require('camel-case');
 
-// src/lib/services/mikro-orm-query.service.ts
-var import_core5 = require("@mikro-orm/core");
-var import_core6 = require("@nestjs-query/core");
-var import_assembler = require("@nestjs-query/core/dist/src/assemblers/assembler.serializer");
-var import_common2 = require("@nestjs/common");
-var import_class_transformer = require("class-transformer");
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-// src/lib/query/filter-query.builder.ts
-var import_core2 = require("@nestjs-query/core");
-var import_lodash = __toESM(require("lodash.merge"), 1);
+var merge__default = /*#__PURE__*/_interopDefault(merge);
 
-// src/lib/query/aggregate.builder.ts
-var import_core = require("@mikro-orm/core");
-var import_common = require("@nestjs/common");
-var import_camel_case = require("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)];
+    return [
+      ...this.getAggregateGroupBySelects(query),
+      ...this.getAggregateFuncSelects(query)
+    ];
   }
   static getAggregateGroupBySelects(query) {
     return (query.groupBy ?? []).map((f) => this.getGroupByAlias(f));
   }
   static getAggregateFuncSelects(query) {
     const aggs = [
-      ["COUNT" /* COUNT */, query.count],
-      ["SUM" /* SUM */, query.sum],
-      ["AVG" /* AVG */, query.avg],
-      ["MAX" /* MAX */, query.max],
-      ["MIN" /* MIN */, query.min]
+      [
+        "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];
+      return [
+        ...cols,
+        ...aliases
+      ];
     }, []);
   }
   static getAggregateAlias(func, field) {
@@ -103,22 +78,25 @@ var AggregateBuilder = class _AggregateBuilder {
           throw new Error("Unknown aggregate column encountered.");
         }
         const [matchedFunc, matchedFieldName] = matchResult.slice(1);
-        const aggFunc = (0, import_camel_case.camelCase)(matchedFunc.toLowerCase());
+        const aggFunc = camelCase.camelCase(matchedFunc.toLowerCase());
         const fieldName = matchedFieldName;
         const aggResult = agg[aggFunc] || {};
         return {
           ...agg,
-          [aggFunc]: { ...aggResult, [fieldName]: response[resultField] }
+          [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
-   */
+  * 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) {
@@ -127,26 +105,26 @@ var AggregateBuilder = class _AggregateBuilder {
     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
-   */
+  * 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" /* COUNT */, aggregate.count, alias, metadata),
-      ...this.createAggSelect("SUM" /* SUM */, aggregate.sum, alias, metadata),
-      ...this.createAggSelect("AVG" /* AVG */, aggregate.avg, alias, metadata),
-      ...this.createAggSelect("MAX" /* MAX */, aggregate.max, alias, metadata),
-      ...this.createAggSelect("MIN" /* MIN */, aggregate.min, 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 import_common.BadRequestException("No aggregate fields found.");
+      throw new common.BadRequestException("No aggregate fields found.");
     }
     selects.forEach(([selectExpr, selectAlias]) => {
-      qb.addSelect((0, import_core.raw)(`${selectExpr} as "${selectAlias}"`));
+      qb.addSelect(core.raw(`${selectExpr} as "${selectAlias}"`));
     });
     return qb;
   }
@@ -157,7 +135,10 @@ var AggregateBuilder = class _AggregateBuilder {
     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)];
+      return [
+        `${func}(${col})`,
+        _AggregateBuilder.getAggregateAlias(func, field)
+      ];
     });
   }
   createGroupBySelect(fields, alias, metadata) {
@@ -167,27 +148,37 @@ var AggregateBuilder = class _AggregateBuilder {
     return fields.map((field) => {
       const columnName = metadata ? this.getColumnName(metadata, field) : field;
       const col = alias ? `\`${alias}\`.\`${columnName}\`` : `\`${columnName}\``;
-      return [`${col}`, _AggregateBuilder.getGroupByAlias(field)];
+      return [
+        `${col}`,
+        _AggregateBuilder.getGroupByAlias(field)
+      ];
     });
   }
 };
 
 // src/lib/query/where.builder.ts
 var WhereBuilder = class {
+  static {
+    __name(this, "WhereBuilder");
+  }
   /**
-   * Builds a MikroORM FilterQuery from a nestjs-query Filter.
-   * @param filter - the filter to build the WHERE clause from.
-   */
+  * Builds a MikroORM FilterQuery from a nestjs-query Filter.
+  * @param filter - the filter to build the WHERE clause from.
+  */
   build(filter) {
     const { and, or } = filter;
     const conditions = [];
     if (and && and.length) {
       const andConditions = and.map((f) => this.build(f));
-      conditions.push({ $and: andConditions });
+      conditions.push({
+        $and: andConditions
+      });
     }
     if (or && or.length) {
       const orConditions = or.map((f) => this.build(f));
-      conditions.push({ $or: orConditions });
+      conditions.push({
+        $or: orConditions
+      });
     }
     const fieldConditions = this.buildFieldComparisons(filter);
     if (Object.keys(fieldConditions).length > 0) {
@@ -199,11 +190,13 @@ var WhereBuilder = class {
     if (conditions.length === 1) {
       return conditions[0];
     }
-    return { $and: conditions };
+    return {
+      $and: conditions
+    };
   }
   /**
-   * Known nestjs-query comparison operators
-   */
+  * Known nestjs-query comparison operators
+  */
   KNOWN_OPERATORS = /* @__PURE__ */ new Set([
     "eq",
     "neq",
@@ -223,8 +216,8 @@ var WhereBuilder = class {
     "notbetween"
   ]);
   /**
-   * Check if an object contains comparison operators (not nested relation filters)
-   */
+  * Check if an object contains comparison operators (not nested relation filters)
+  */
   isComparisonObject(obj) {
     if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
       return false;
@@ -233,9 +226,9 @@ var WhereBuilder = class {
     return keys.some((key) => this.KNOWN_OPERATORS.has(key.toLowerCase()));
   }
   /**
-   * Creates field comparisons from a filter. This method will ignore and/or properties.
-   * @param filter - the filter with fields to create comparisons for.
-   */
+  * Creates field comparisons from a filter. This method will ignore and/or properties.
+  * @param filter - the filter with fields to create comparisons for.
+  */
   buildFieldComparisons(filter) {
     const result = {};
     Object.keys(filter).forEach((field) => {
@@ -253,9 +246,9 @@ var WhereBuilder = class {
     return result;
   }
   /**
-   * Builds a MikroORM comparison from a nestjs-query FilterFieldComparison.
-   * @param comparison - the comparison to convert.
-   */
+  * Builds a MikroORM comparison from a nestjs-query FilterFieldComparison.
+  * @param comparison - the comparison to convert.
+  */
   buildComparison(comparison) {
     const conditions = {};
     const operators = Object.keys(comparison);
@@ -270,75 +263,121 @@ var WhereBuilder = class {
     return conditions;
   }
   /**
-   * Maps a nestjs-query operator to a MikroORM operator.
-   * @param operator - the nestjs-query operator.
-   * @param value - the value to compare.
-   */
+  * Maps a nestjs-query operator to a MikroORM operator.
+  * @param operator - the nestjs-query operator.
+  * @param value - the value to compare.
+  */
   mapOperator(operator, value) {
     const normalizedOp = operator.toLowerCase();
     switch (normalizedOp) {
       case "eq":
-        return { $eq: value };
+        return {
+          $eq: value
+        };
       case "neq":
-        return { $ne: value };
+        return {
+          $ne: value
+        };
       case "gt":
-        return { $gt: value };
+        return {
+          $gt: value
+        };
       case "gte":
-        return { $gte: value };
+        return {
+          $gte: value
+        };
       case "lt":
-        return { $lt: value };
+        return {
+          $lt: value
+        };
       case "lte":
-        return { $lte: value };
+        return {
+          $lte: value
+        };
       case "like":
-        return { $like: value };
+        return {
+          $like: value
+        };
       case "notlike":
-        return { $not: { $like: value } };
+        return {
+          $not: {
+            $like: value
+          }
+        };
       case "ilike":
-        return { $ilike: value };
+        return {
+          $ilike: value
+        };
       case "notilike":
-        return { $not: { $ilike: value } };
+        return {
+          $not: {
+            $ilike: value
+          }
+        };
       case "in":
-        return { $in: value };
+        return {
+          $in: value
+        };
       case "notin":
-        return { $nin: value };
+        return {
+          $nin: value
+        };
       case "is":
         if (value === null) {
-          return { $eq: null };
+          return {
+            $eq: null
+          };
         }
         if (value === true) {
-          return { $eq: true };
+          return {
+            $eq: true
+          };
         }
         if (value === false) {
-          return { $eq: false };
+          return {
+            $eq: false
+          };
         }
         throw new Error(`Unexpected is operator param ${JSON.stringify(value)}`);
       case "isnot":
         if (value === null) {
-          return { $ne: null };
+          return {
+            $ne: null
+          };
         }
         if (value === true) {
-          return { $ne: true };
+          return {
+            $ne: true
+          };
         }
         if (value === false) {
-          return { $ne: false };
+          return {
+            $ne: false
+          };
         }
         throw new Error(`Unexpected isNot operator param ${JSON.stringify(value)}`);
       case "between":
         if (this.isBetweenValue(value)) {
-          return { $gte: value.lower, $lte: value.upper };
+          return {
+            $gte: value.lower,
+            $lte: value.upper
+          };
         }
-        throw new Error(
-          `Invalid value for between expected {lower: val, upper: val} got ${JSON.stringify(value)}`
-        );
+        throw new Error(`Invalid value for between expected {lower: val, upper: val} got ${JSON.stringify(value)}`);
       case "notbetween":
         if (this.isBetweenValue(value)) {
           return {
-            $or: [{ $lt: value.lower }, { $gt: value.upper }]
+            $or: [
+              {
+                $lt: value.lower
+              },
+              {
+                $gt: value.upper
+              }
+            ]
           };
         }
-        throw new Error(
-          `Invalid value for not between expected {lower: val, upper: val} got ${JSON.stringify(value)}`
-        );
+        throw new Error(`Invalid value for not between expected {lower: val, upper: val} got ${JSON.stringify(value)}`);
       default:
         throw new Error(`Unknown operator ${operator}`);
     }
@@ -350,16 +389,22 @@ var WhereBuilder = class {
 
 // src/lib/query/filter-query.builder.ts
 var FilterQueryBuilder = class {
+  static {
+    __name(this, "FilterQueryBuilder");
+  }
+  repo;
+  whereBuilder;
+  aggregateBuilder;
   constructor(repo, whereBuilder = new WhereBuilder(), aggregateBuilder = new AggregateBuilder()) {
     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.
-   */
+  * Create a MikroORM QueryBuilder with `WHERE`, `ORDER BY` and `LIMIT/OFFSET` clauses.
+  *
+  * @param query - the query to apply.
+  */
   select(query) {
     const alias = this.getEntityAlias();
     const qb = this.createQueryBuilder(alias);
@@ -374,9 +419,15 @@ var FilterQueryBuilder = class {
     const metadata = this.repo.getEntityManager().getMetadata().get(this.repo.getEntityName());
     const primaryKey = metadata.primaryKeys[0];
     if (Array.isArray(id)) {
-      qb.where({ [primaryKey]: { $in: id } });
+      qb.where({
+        [primaryKey]: {
+          $in: id
+        }
+      });
     } else {
-      qb.where({ [primaryKey]: id });
+      qb.where({
+        [primaryKey]: id
+      });
     }
     this.applyFilter(qb, query.filter, alias);
     this.applySorting(qb, query.sorting, alias);
@@ -393,10 +444,10 @@ var FilterQueryBuilder = class {
     return qb;
   }
   /**
-   * Applies paging to a MikroORM query builder
-   * @param qb - the MikroORM QueryBuilder
-   * @param paging - the Paging options.
-   */
+  * Applies paging to a MikroORM query builder
+  * @param qb - the MikroORM QueryBuilder
+  * @param paging - the Paging options.
+  */
   applyPaging(qb, paging) {
     if (!paging) {
       return qb;
@@ -410,22 +461,22 @@ var FilterQueryBuilder = class {
     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
-   */
+  * 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);
   }
   /**
-   * Applies the filter from a Query to a MikroORM QueryBuilder.
-   *
-   * @param qb - the MikroORM QueryBuilder.
-   * @param filter - the filter.
-   * @param _alias - optional alias to use to qualify an identifier (unused in MikroORM)
-   */
+  * Applies the filter from a Query to a MikroORM QueryBuilder.
+  *
+  * @param qb - the MikroORM QueryBuilder.
+  * @param filter - the filter.
+  * @param _alias - optional alias to use to qualify an identifier (unused in MikroORM)
+  */
   applyFilter(qb, filter, _alias) {
     if (!filter) {
       return qb;
@@ -434,26 +485,26 @@ var FilterQueryBuilder = class {
     return qb.andWhere(mikroOrmFilter);
   }
   /**
-   * Applies the ORDER BY clause to a MikroORM QueryBuilder.
-   * @param qb - the MikroORM QueryBuilder.
-   * @param sorts - an array of SortFields to create the ORDER BY clause.
-   * @param _alias - optional alias to use to qualify an identifier (unused in MikroORM)
-   */
+  * Applies the ORDER BY clause to a MikroORM QueryBuilder.
+  * @param qb - the MikroORM QueryBuilder.
+  * @param sorts - an array of SortFields to create the ORDER BY clause.
+  * @param _alias - optional alias to use to qualify an identifier (unused in MikroORM)
+  */
   applySorting(qb, sorts, _alias) {
     if (!sorts || sorts.length === 0) {
       return qb;
     }
-    const orderBy = sorts.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 };
-      },
-      {}
-    );
+    const orderBy = sorts.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
+      };
+    }, {});
     return qb.orderBy(orderBy);
   }
   applyGroupBy(qb, groupBy, _alias) {
@@ -469,36 +520,33 @@ var FilterQueryBuilder = class {
     if (!groupBy || groupBy.length === 0) {
       return qb;
     }
-    const orderBy = groupBy.reduce(
-      (acc, field) => ({
-        ...acc,
-        [field]: "asc"
-      }),
-      {}
-    );
+    const orderBy = groupBy.reduce((acc, field) => ({
+      ...acc,
+      [field]: "asc"
+    }), {});
     return qb.orderBy(orderBy);
   }
   /**
-   * Create a MikroORM QueryBuilder.
-   */
+  * Create a MikroORM QueryBuilder.
+  */
   createQueryBuilder(alias) {
     return this.repo.createQueryBuilder(alias);
   }
   /**
-   * Gets the entity alias based on the entity name.
-   */
+  * Gets the entity alias based on the entity name.
+  */
   getEntityAlias() {
     const em = this.repo.getEntityManager();
     const meta = em.getMetadata().get(this.repo.getEntityName());
     return meta.className;
   }
   /**
-   * Checks if a filter references any relations.
-   * @param filter
-   * @private
-   *
-   * @returns true if there are any referenced relations
-   */
+  * Checks if a filter references any relations.
+  * @param filter
+  * @private
+  *
+  * @returns true if there are any referenced relations
+  */
   filterHasRelations(filter) {
     if (!filter) {
       return false;
@@ -507,7 +555,7 @@ var FilterQueryBuilder = class {
   }
   getReferencedRelations(filter) {
     const relationNames = this.relationNames;
-    const referencedFields = (0, import_core2.getFilterFields)(filter);
+    const referencedFields = core$1.getFilterFields(filter);
     return referencedFields.filter((f) => relationNames.includes(f));
   }
   getReferencedRelationsRecursive(metadataOrFilter = {}, filter) {
@@ -524,14 +572,12 @@ var FilterQueryBuilder = class {
       metadata = em.getMetadata().get(this.repo.getEntityName());
       actualFilter = metadataOrFilter;
     }
-    const referencedFields = Array.from(
-      new Set(Object.keys(actualFilter))
-    );
+    const referencedFields = Array.from(new Set(Object.keys(actualFilter)));
     return referencedFields.reduce((prev, curr) => {
       const currFilterValue = actualFilter[curr];
       if ((curr === "and" || curr === "or") && currFilterValue) {
         for (const subFilter of currFilterValue) {
-          prev = (0, import_lodash.default)(prev, this.getReferencedRelationsRecursiveInternal(metadata, subFilter));
+          prev = merge__default.default(prev, this.getReferencedRelationsRecursiveInternal(metadata, subFilter));
         }
       }
       const referencedRelation = metadata.relations.find((r) => r.name === curr);
@@ -541,7 +587,7 @@ var FilterQueryBuilder = class {
       const nestedRelations = nestedFilter ? this.getReferencedRelationsRecursiveInternal(targetMeta, nestedFilter) : {};
       return {
         ...prev,
-        [curr]: (0, import_lodash.default)(prev[curr] ?? {}, nestedRelations)
+        [curr]: merge__default.default(prev[curr] ?? {}, nestedRelations)
       };
     }, {});
   }
@@ -552,7 +598,7 @@ var FilterQueryBuilder = class {
       const currFilterValue = filter[curr];
       if ((curr === "and" || curr === "or") && currFilterValue) {
         for (const subFilter of currFilterValue) {
-          prev = (0, import_lodash.default)(prev, this.getReferencedRelationsRecursiveInternal(metadata, subFilter));
+          prev = merge__default.default(prev, this.getReferencedRelationsRecursiveInternal(metadata, subFilter));
         }
       }
       const referencedRelation = metadata.relations.find((r) => r.name === curr);
@@ -562,7 +608,7 @@ var FilterQueryBuilder = class {
       const nestedRelations = nestedFilter ? this.getReferencedRelationsRecursiveInternal(targetMeta, nestedFilter) : {};
       return {
         ...prev,
-        [curr]: (0, import_lodash.default)(prev[curr] ?? {}, nestedRelations)
+        [curr]: merge__default.default(prev[curr] ?? {}, nestedRelations)
       };
     }, {});
   }
@@ -575,46 +621,101 @@ var FilterQueryBuilder = class {
 
 // src/lib/query/sql-comparison.builder.ts
 var SQLComparisonBuilder = class {
+  static {
+    __name(this, "SQLComparisonBuilder");
+  }
   /**
-   * Maps a comparison operator to MikroORM filter format.
-   *
-   * @param field - the property in Entity to create the comparison for.
-   * @param cmp - the FilterComparisonOperator (eq, neq, gt, etc...)
-   * @param val - the value to compare to
-   */
+  * Maps a comparison operator to MikroORM filter format.
+  *
+  * @param field - the property in Entity to create the comparison for.
+  * @param cmp - the FilterComparisonOperator (eq, neq, gt, etc...)
+  * @param val - the value to compare to
+  */
   build(field, cmp, val) {
     const normalizedCmp = cmp.toLowerCase();
     switch (normalizedCmp) {
       case "eq":
-        return { [field]: { $eq: val } };
+        return {
+          [field]: {
+            $eq: val
+          }
+        };
       case "neq":
-        return { [field]: { $ne: val } };
+        return {
+          [field]: {
+            $ne: val
+          }
+        };
       case "gt":
-        return { [field]: { $gt: val } };
+        return {
+          [field]: {
+            $gt: val
+          }
+        };
       case "gte":
-        return { [field]: { $gte: val } };
+        return {
+          [field]: {
+            $gte: val
+          }
+        };
       case "lt":
-        return { [field]: { $lt: val } };
+        return {
+          [field]: {
+            $lt: val
+          }
+        };
       case "lte":
-        return { [field]: { $lte: val } };
+        return {
+          [field]: {
+            $lte: val
+          }
+        };
       case "like":
-        return { [field]: { $like: val } };
+        return {
+          [field]: {
+            $like: val
+          }
+        };
       case "notlike":
-        return { [field]: { $not: { $like: val } } };
+        return {
+          [field]: {
+            $not: {
+              $like: val
+            }
+          }
+        };
       case "ilike":
-        return { [field]: { $ilike: val } };
+        return {
+          [field]: {
+            $ilike: val
+          }
+        };
       case "notilike":
-        return { [field]: { $not: { $ilike: val } } };
+        return {
+          [field]: {
+            $not: {
+              $ilike: val
+            }
+          }
+        };
       case "is":
         return this.isComparison(field, val);
       case "isnot":
         return this.isNotComparison(field, val);
       case "in":
         this.checkNonEmptyArray(val);
-        return { [field]: { $in: val } };
+        return {
+          [field]: {
+            $in: val
+          }
+        };
       case "notin":
         this.checkNonEmptyArray(val);
-        return { [field]: { $nin: val } };
+        return {
+          [field]: {
+            $nin: val
+          }
+        };
       case "between":
         return this.betweenComparison(field, val);
       case "notbetween":
@@ -625,25 +726,49 @@ var SQLComparisonBuilder = class {
   }
   isComparison(field, val) {
     if (val === null) {
-      return { [field]: { $eq: null } };
+      return {
+        [field]: {
+          $eq: null
+        }
+      };
     }
     if (val === true) {
-      return { [field]: { $eq: true } };
+      return {
+        [field]: {
+          $eq: true
+        }
+      };
     }
     if (val === false) {
-      return { [field]: { $eq: false } };
+      return {
+        [field]: {
+          $eq: false
+        }
+      };
     }
     throw new Error(`Unexpected is operator param ${JSON.stringify(val)}`);
   }
   isNotComparison(field, val) {
     if (val === null) {
-      return { [field]: { $ne: null } };
+      return {
+        [field]: {
+          $ne: null
+        }
+      };
     }
     if (val === true) {
-      return { [field]: { $ne: true } };
+      return {
+        [field]: {
+          $ne: true
+        }
+      };
     }
     if (val === false) {
-      return { [field]: { $ne: false } };
+      return {
+        [field]: {
+          $ne: false
+        }
+      };
     }
     throw new Error(`Unexpected isNot operator param ${JSON.stringify(val)}`);
   }
@@ -664,19 +789,26 @@ var SQLComparisonBuilder = class {
         }
       };
     }
-    throw new Error(
-      `Invalid value for between expected {lower: val, upper: val} got ${JSON.stringify(val)}`
-    );
+    throw new Error(`Invalid value for between expected {lower: val, upper: val} got ${JSON.stringify(val)}`);
   }
   notBetweenComparison(field, val) {
     if (this.isBetweenVal(val)) {
       return {
-        $or: [{ [field]: { $lt: val.lower } }, { [field]: { $gt: val.upper } }]
+        $or: [
+          {
+            [field]: {
+              $lt: val.lower
+            }
+          },
+          {
+            [field]: {
+              $gt: val.upper
+            }
+          }
+        ]
       };
     }
-    throw new Error(
-      `Invalid value for not between expected {lower: val, upper: val} got ${JSON.stringify(val)}`
-    );
+    throw new Error(`Invalid value for not between expected {lower: val, upper: val} got ${JSON.stringify(val)}`);
   }
   isBetweenVal(val) {
     return val !== null && typeof val === "object" && "lower" in val && "upper" in val;
@@ -685,21 +817,24 @@ var SQLComparisonBuilder = class {
 
 // src/lib/query/relation-query.builder.ts
 var RelationQueryBuilder = class {
+  static {
+    __name(this, "RelationQueryBuilder");
+  }
+  repo;
+  relation;
+  filterQueryBuilder;
   constructor(repo, relation) {
     this.repo = repo;
     this.relation = relation;
     const relationMeta = this.getRelationMeta();
     const em = this.repo.getEntityManager();
-    const relationRepo = em.getRepository(
-      relationMeta.type
-    );
+    const relationRepo = em.getRepository(relationMeta.type);
     this.filterQueryBuilder = new FilterQueryBuilder(relationRepo);
   }
-  filterQueryBuilder;
   /**
-   * 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.
-   */
+  * 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.
+  */
   select(entity, query) {
     const relationMeta = this.getRelationMeta();
     const em = this.repo.getEntityManager();
@@ -731,8 +866,8 @@ var RelationQueryBuilder = class {
     return qb;
   }
   /**
-   * Executes the select query and returns the results.
-   */
+  * Executes the select query and returns the results.
+  */
   async selectAndExecute(entity, query) {
     const qb = this.select(entity, query);
     return qb.getResultList();
@@ -797,7 +932,9 @@ var RelationQueryBuilder = class {
           fkValue = relationValue;
         }
       }
-      return { [relationPrimaryKey]: fkValue };
+      return {
+        [relationPrimaryKey]: fkValue
+      };
     }
     if (relationMeta.kind === "1:1") {
       if (relationMeta.owner) {
@@ -815,25 +952,39 @@ var RelationQueryBuilder = class {
           }
         }
         if (fkValue === void 0 && relationMeta.inversedBy) {
-          return { [relationMeta.inversedBy]: entityId };
+          return {
+            [relationMeta.inversedBy]: entityId
+          };
         }
-        return { [relationPrimaryKey]: fkValue };
+        return {
+          [relationPrimaryKey]: fkValue
+        };
       } else {
-        return { [relationMeta.mappedBy]: entityId };
+        return {
+          [relationMeta.mappedBy]: entityId
+        };
       }
     }
     if (relationMeta.kind === "1:m") {
       const mappedBy = relationMeta.mappedBy;
-      return { [mappedBy]: entityId };
+      return {
+        [mappedBy]: entityId
+      };
     }
     if (relationMeta.kind === "m:n") {
       if (relationMeta.owner) {
-        return { [relationMeta.inversedBy]: entityId };
+        return {
+          [relationMeta.inversedBy]: entityId
+        };
       } else {
-        return { [relationMeta.mappedBy]: entityId };
+        return {
+          [relationMeta.mappedBy]: entityId
+        };
       }
     }
-    return { [entityPrimaryKey]: entityId };
+    return {
+      [entityPrimaryKey]: entityId
+    };
   }
   getRelationMeta() {
     const em = this.repo.getEntityManager();
@@ -860,38 +1011,27 @@ var RelationQueryBuilder = class {
     });
   }
 };
-
-// src/lib/services/relation-query.service.ts
-var import_core3 = require("@mikro-orm/core");
-var import_core4 = require("@nestjs-query/core");
 var RelationQueryService = class {
+  static {
+    __name(this, "RelationQueryService");
+  }
   async queryRelations(RelationClass, relationName, dto, query) {
     if (Array.isArray(dto)) {
       return this.batchQueryRelations(RelationClass, relationName, dto, query);
     }
-    const assembler = import_core4.AssemblerFactory.getAssembler(
-      RelationClass,
-      this.getRelationEntity(relationName)
-    );
+    const assembler = core$1.AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
     const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
-    return assembler.convertAsyncToDTOs(
-      relationQueryBuilder.selectAndExecute(dto, assembler.convertQuery(query))
-    );
+    return assembler.convertAsyncToDTOs(relationQueryBuilder.selectAndExecute(dto, assembler.convertQuery(query)));
   }
   async aggregateRelations(RelationClass, relationName, dto, filter, aggregate) {
     if (Array.isArray(dto)) {
       return this.batchAggregateRelations(RelationClass, relationName, dto, filter, aggregate);
     }
-    const assembler = import_core4.AssemblerFactory.getAssembler(
-      RelationClass,
-      this.getRelationEntity(relationName)
-    );
+    const assembler = core$1.AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
     const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
-    const rawResults = await relationQueryBuilder.aggregate(
-      dto,
-      assembler.convertQuery({ filter }),
-      assembler.convertAggregateQuery(aggregate)
-    );
+    const rawResults = await relationQueryBuilder.aggregate(dto, assembler.convertQuery({
+      filter
+    }), assembler.convertAggregateQuery(aggregate));
     const aggResponse = AggregateBuilder.convertToAggregateResponse(rawResults);
     return aggResponse.map((agg) => {
       const res = assembler.convertAggregateResponse(agg);
@@ -902,43 +1042,37 @@ var RelationQueryService = class {
     if (Array.isArray(dto)) {
       return this.batchCountRelations(RelationClass, relationName, dto, filter);
     }
-    const assembler = import_core4.AssemblerFactory.getAssembler(
-      RelationClass,
-      this.getRelationEntity(relationName)
-    );
+    const assembler = core$1.AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
     const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
-    return relationQueryBuilder.count(dto, assembler.convertQuery({ filter }));
+    return relationQueryBuilder.count(dto, assembler.convertQuery({
+      filter
+    }));
   }
   async findRelation(RelationClass, relationName, dto, opts) {
     if (Array.isArray(dto)) {
       return this.batchFindRelations(RelationClass, relationName, dto, opts);
     }
-    const assembler = import_core4.AssemblerFactory.getAssembler(
-      RelationClass,
-      this.getRelationEntity(relationName)
-    );
+    const assembler = core$1.AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
     const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
     const relations = await relationQueryBuilder.selectAndExecute(dto, {
       filter: opts?.filter,
-      paging: { limit: 1 }
+      paging: {
+        limit: 1
+      }
     });
     const relationEntity = relations[0];
     return relationEntity ? assembler.convertToDTO(relationEntity) : void 0;
   }
   /**
-   * Add a single relation.
-   * @param id - The id of the entity to add the relation to.
-   * @param relationName - The name of the relation to query for.
-   * @param relationIds - The ids of relations to add.
-   * @param opts - Addition options
-   */
+  * Add a single relation.
+  * @param id - The id of the entity to add the relation to.
+  * @param relationName - The name of the relation to query for.
+  * @param relationIds - The ids of relations to add.
+  * @param opts - Addition options
+  */
   async addRelations(relationName, id, relationIds, opts) {
     const entity = await this.getById(id, opts);
-    const relations = await this.getRelations(
-      relationName,
-      relationIds,
-      opts?.relationFilter
-    );
+    const relations = await this.getRelations(relationName, relationIds, opts?.relationFilter);
     if (!this.foundAllRelations(relationIds, relations)) {
       throw new Error(`Unable to find all ${relationName} to add to ${this.EntityClass.name}`);
     }
@@ -952,21 +1086,17 @@ var RelationQueryService = class {
     return entity;
   }
   /**
-   * Set the relations on the entity.
-   *
-   * @param id - The id of the entity to set the relation on.
-   * @param relationName - The name of the relation to query for.
-   * @param relationIds - The ids of the relation to set on the entity. If the relationIds is empty all relations
-   * will be removed.
-   * @param opts - Additional options
-   */
+  * Set the relations on the entity.
+  *
+  * @param id - The id of the entity to set the relation on.
+  * @param relationName - The name of the relation to query for.
+  * @param relationIds - The ids of the relation to set on the entity. If the relationIds is empty all relations
+  * will be removed.
+  * @param opts - Additional options
+  */
   async setRelations(relationName, id, relationIds, opts) {
     const entity = await this.getById(id, opts);
-    const relations = await this.getRelations(
-      relationName,
-      relationIds,
-      opts?.relationFilter
-    );
+    const relations = await this.getRelations(relationName, relationIds, opts?.relationFilter);
     if (relationIds.length) {
       if (!this.foundAllRelations(relationIds, relations)) {
         throw new Error(`Unable to find all ${relationName} to set on ${this.EntityClass.name}`);
@@ -981,37 +1111,37 @@ var RelationQueryService = class {
     return entity;
   }
   /**
-   * Set the relation on the entity.
-   *
-   * @param id - The id of the entity to set the relation on.
-   * @param relationName - The name of the relation to query for.
-   * @param relationId - The id of the relation to set on the entity.
-   * @param opts - Additional options
-   */
+  * Set the relation on the entity.
+  *
+  * @param id - The id of the entity to set the relation on.
+  * @param relationName - The name of the relation to query for.
+  * @param relationId - The id of the relation to set on the entity.
+  * @param opts - Additional options
+  */
   async setRelation(relationName, id, relationId, opts) {
     const entity = await this.getById(id, opts);
-    const relation = (await this.getRelations(relationName, [relationId], opts?.relationFilter))[0];
+    const relation = (await this.getRelations(relationName, [
+      relationId
+    ], opts?.relationFilter))[0];
     if (!relation) {
       throw new Error(`Unable to find ${relationName} to set on ${this.EntityClass.name}`);
     }
-    (0, import_core3.wrap)(entity).assign({ [relationName]: relation });
+    core.wrap(entity).assign({
+      [relationName]: relation
+    });
     await this.repo.getEntityManager().flush();
     return entity;
   }
   /**
-   * Removes multiple relations.
-   * @param id - The id of the entity to add the relation to.
-   * @param relationName - The name of the relation to query for.
-   * @param relationIds - The ids of the relations to add.
-   * @param opts - Additional options
-   */
+  * Removes multiple relations.
+  * @param id - The id of the entity to add the relation to.
+  * @param relationName - The name of the relation to query for.
+  * @param relationIds - The ids of the relations to add.
+  * @param opts - Additional options
+  */
   async removeRelations(relationName, id, relationIds, opts) {
     const entity = await this.getById(id, opts);
-    const relations = await this.getRelations(
-      relationName,
-      relationIds,
-      opts?.relationFilter
-    );
+    const relations = await this.getRelations(relationName, relationIds, opts?.relationFilter);
     if (!this.foundAllRelations(relationIds, relations)) {
       throw new Error(`Unable to find all ${relationName} to remove from ${this.EntityClass.name}`);
     }
@@ -1026,26 +1156,30 @@ var RelationQueryService = class {
     return entity;
   }
   /**
-   * Remove the relation on the entity.
-   *
-   * @param id - The id of the entity to set the relation on.
-   * @param relationName - The name of the relation to query for.
-   * @param relationId - The id of the relation to set on the entity.
-   */
+  * Remove the relation on the entity.
+  *
+  * @param id - The id of the entity to set the relation on.
+  * @param relationName - The name of the relation to query for.
+  * @param relationId - The id of the relation to set on the entity.
+  */
   async removeRelation(relationName, id, relationId, opts) {
     const entity = await this.getById(id, opts);
-    const relation = (await this.getRelations(relationName, [relationId], opts?.relationFilter))[0];
+    const relation = (await this.getRelations(relationName, [
+      relationId
+    ], opts?.relationFilter))[0];
     if (!relation) {
       throw new Error(`Unable to find ${relationName} to remove from ${this.EntityClass.name}`);
     }
     const meta = this.getRelationMeta(relationName);
     if (meta.kind === "1:1" || meta.kind === "m:1") {
       const fkFieldName = `${relationName}Id`;
-      const assignData = { [relationName]: null };
+      const assignData = {
+        [relationName]: null
+      };
       if (fkFieldName in entity) {
         assignData[fkFieldName] = null;
       }
-      (0, import_core3.wrap)(entity).assign(assignData);
+      core.wrap(entity).assign(assignData);
     } else {
       const collection = entity[relationName];
       if (collection && typeof collection.remove === "function") {
@@ -1060,95 +1194,79 @@ var RelationQueryService = class {
     return new RelationQueryBuilder(this.repo, name);
   }
   /**
-   * Query for an array of relations for multiple dtos.
-   * @param RelationClass - The class to serialize the relations into.
-   * @param entities - The entities to query relations for.
-   * @param relationName - The name of relation to query for.
-   * @param query - A query to filter, page or sort relations.
-   */
+  * Query for an array of relations for multiple dtos.
+  * @param RelationClass - The class to serialize the relations into.
+  * @param entities - The entities to query relations for.
+  * @param relationName - The name of relation to query for.
+  * @param query - A query to filter, page or sort relations.
+  */
   async batchQueryRelations(RelationClass, relationName, entities, query) {
-    const assembler = import_core4.AssemblerFactory.getAssembler(
-      RelationClass,
-      this.getRelationEntity(relationName)
-    );
+    const assembler = core$1.AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
     const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
     const convertedQuery = assembler.convertQuery(query);
     const results = /* @__PURE__ */ new Map();
-    await Promise.all(
-      entities.map(async (entity) => {
-        const relations = await relationQueryBuilder.selectAndExecute(entity, convertedQuery);
-        const relationDtos = assembler.convertToDTOs(relations);
-        if (relationDtos.length > 0) {
-          results.set(entity, relationDtos);
-        }
-      })
-    );
+    await Promise.all(entities.map(async (entity) => {
+      const relations = await relationQueryBuilder.selectAndExecute(entity, convertedQuery);
+      const relationDtos = assembler.convertToDTOs(relations);
+      if (relationDtos.length > 0) {
+        results.set(entity, relationDtos);
+      }
+    }));
     return results;
   }
   /**
-   * Query for an array of relations for multiple dtos.
-   * @param RelationClass - The class to serialize the relations into.
-   * @param entities - The entities to query relations for.
-   * @param relationName - The name of relation to query for.
-   * @param query - A query to filter, page or sort relations.
-   */
+  * Query for an array of relations for multiple dtos.
+  * @param RelationClass - The class to serialize the relations into.
+  * @param entities - The entities to query relations for.
+  * @param relationName - The name of relation to query for.
+  * @param query - A query to filter, page or sort relations.
+  */
   async batchAggregateRelations(RelationClass, relationName, entities, filter, aggregate) {
-    const assembler = import_core4.AssemblerFactory.getAssembler(
-      RelationClass,
-      this.getRelationEntity(relationName)
-    );
+    const assembler = core$1.AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
     const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
-    const convertedQuery = assembler.convertQuery({ filter });
+    const convertedQuery = assembler.convertQuery({
+      filter
+    });
     const results = /* @__PURE__ */ new Map();
-    await Promise.all(
-      entities.map(async (entity) => {
-        const rawAggregates = await relationQueryBuilder.aggregate(
-          entity,
-          convertedQuery,
-          assembler.convertAggregateQuery(aggregate)
-        );
-        const aggResponse = AggregateBuilder.convertToAggregateResponse(rawAggregates);
-        results.set(
-          entity,
-          aggResponse.map((agg) => assembler.convertAggregateResponse(agg))
-        );
-      })
-    );
+    await Promise.all(entities.map(async (entity) => {
+      const rawAggregates = await relationQueryBuilder.aggregate(entity, convertedQuery, assembler.convertAggregateQuery(aggregate));
+      const aggResponse = AggregateBuilder.convertToAggregateResponse(rawAggregates);
+      results.set(entity, aggResponse.map((agg) => assembler.convertAggregateResponse(agg)));
+    }));
     return results;
   }
   /**
-   * Count the number of relations for multiple dtos.
-   * @param RelationClass - The class to serialize the relations into.
-   * @param entities - The entities to query relations for.
-   * @param relationName - The name of relation to query for.
-   * @param filter - The filter to apply to the relation query.
-   */
+  * Count the number of relations for multiple dtos.
+  * @param RelationClass - The class to serialize the relations into.
+  * @param entities - The entities to query relations for.
+  * @param relationName - The name of relation to query for.
+  * @param filter - The filter to apply to the relation query.
+  */
   async batchCountRelations(RelationClass, relationName, entities, filter) {
-    const assembler = import_core4.AssemblerFactory.getAssembler(
-      RelationClass,
-      this.getRelationEntity(relationName)
-    );
+    const assembler = core$1.AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
     const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
-    const convertedQuery = assembler.convertQuery({ filter });
+    const convertedQuery = assembler.convertQuery({
+      filter
+    });
     const results = /* @__PURE__ */ new Map();
-    await Promise.all(
-      entities.map(async (entity) => {
-        const count = await relationQueryBuilder.count(entity, convertedQuery);
-        results.set(entity, count);
-      })
-    );
+    await Promise.all(entities.map(async (entity) => {
+      const count = await relationQueryBuilder.count(entity, convertedQuery);
+      results.set(entity, count);
+    }));
     return results;
   }
   /**
-   * Query for a relation for multiple dtos.
-   * @param RelationClass - The class to serialize the relations into.
-   * @param dtos - The dto to query relations for.
-   * @param relationName - The name of relation to query for.
-   * @param query - A query to filter, page or sort relations.
-   */
+  * Query for a relation for multiple dtos.
+  * @param RelationClass - The class to serialize the relations into.
+  * @param dtos - The dto to query relations for.
+  * @param relationName - The name of relation to query for.
+  * @param query - A query to filter, page or sort relations.
+  */
   async batchFindRelations(RelationClass, relationName, dtos, opts) {
     const batchResults = await this.batchQueryRelations(RelationClass, relationName, dtos, {
-      paging: { limit: 1 },
+      paging: {
+        limit: 1
+      },
       filter: opts?.filter
     });
     const results = /* @__PURE__ */ new Map();
@@ -1182,44 +1300,52 @@ var RelationQueryService = class {
     const RelationEntity = relationMeta.entity();
     const relationMetadata = em.getMetadata().get(RelationEntity);
     const primaryKey = relationMetadata.primaryKeys[0];
-    const idFilter = { [primaryKey]: { $in: ids } };
+    const idFilter = {
+      [primaryKey]: {
+        $in: ids
+      }
+    };
     if (filter) {
       const whereBuilder = this.filterQueryBuilder.whereBuilder;
-      const additionalFilter = whereBuilder.build(
-        filter
-      );
+      const additionalFilter = whereBuilder.build(filter);
       return em.find(RelationEntity, {
-        $and: [idFilter, additionalFilter]
+        $and: [
+          idFilter,
+          additionalFilter
+        ]
       });
     }
     return em.find(RelationEntity, idFilter);
   }
   foundAllRelations(relationIds, relations) {
-    return (/* @__PURE__ */ new Set([...relationIds])).size === relations.length;
+    return (/* @__PURE__ */ new Set([
+      ...relationIds
+    ])).size === relations.length;
   }
 };
 
 // src/lib/services/mikro-orm-query.service.ts
 var MikroOrmQueryService = class extends RelationQueryService {
+  static {
+    __name(this, "MikroOrmQueryService");
+  }
+  repo;
+  filterQueryBuilder;
+  useSoftDelete;
   constructor(repo, opts) {
-    super();
-    this.repo = repo;
+    super(), this.repo = repo;
     this.filterQueryBuilder = opts?.filterQueryBuilder ?? new FilterQueryBuilder(this.repo);
     this.useSoftDelete = opts?.useSoftDelete ?? false;
-    const serializer = (0, import_assembler.getAssemblerSerializer)(this.EntityClass);
+    const serializer = assembler_serializer.getAssemblerSerializer(this.EntityClass);
     if (!serializer) {
-      (0, import_core6.AssemblerSerializer)((e) => {
-        const json = (0, import_class_transformer.instanceToPlain)(e, {
+      core$1.AssemblerSerializer((e) => {
+        const json = classTransformer.instanceToPlain(e, {
           enableImplicitConversion: true,
           excludeExtraneousValues: true,
           exposeDefaultValues: true
         });
-        const jsonWithRemovedEmptyObjects = Object.fromEntries(
-          Object.entries(json).filter(
-            ([, value]) => !(value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0)
-          )
-        );
-        const wrapped = (0, import_core5.wrap)(e, true);
+        const jsonWithRemovedEmptyObjects = Object.fromEntries(Object.entries(json).filter(([, value]) => !(value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0)));
+        const wrapped = core.wrap(e, true);
         const ormJson = "toObject" in wrapped ? wrapped.toObject() : {};
         const data = {
           ...ormJson,
@@ -1227,57 +1353,59 @@ var MikroOrmQueryService = class extends RelationQueryService {
         };
         return data;
       })(this.EntityClass);
-      (0, import_core6.AssemblerDeserializer)((d) => {
-        const entity = this.repo.getEntityManager().create(this.EntityClass, (0, import_class_transformer.instanceToPlain)(d));
+      core$1.AssemblerDeserializer((d) => {
+        const entity = this.repo.getEntityManager().create(this.EntityClass, classTransformer.instanceToPlain(d));
         return entity;
       })(this.EntityClass);
     }
   }
-  filterQueryBuilder;
-  useSoftDelete;
   get EntityClass() {
     const em = this.repo.getEntityManager();
     const metadata = em.getMetadata().get(this.repo.getEntityName());
     return metadata.class;
   }
   /**
-   * Query for multiple entities, using a Query from `@nestjs-query/core`.
-   *
-   * @example
-   * ```ts
-   * const todoItems = await this.service.query({
-   *   filter: { title: { eq: 'Foo' } },
-   *   paging: { limit: 10 },
-   *   sorting: [{ field: "create", direction: SortDirection.DESC }],
-   * });
-   * ```
-   * @param query - The Query used to filter, page, and sort rows.
-   */
+  * Query for multiple entities, using a Query from `@nestjs-query/core`.
+  *
+  * @example
+  * ```ts
+  * const todoItems = await this.service.query({
+  *   filter: { title: { eq: 'Foo' } },
+  *   paging: { limit: 10 },
+  *   sorting: [{ field: "create", direction: SortDirection.DESC }],
+  * });
+  * ```
+  * @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();
   }
   async aggregate(filter, aggregate) {
-    const qb = this.filterQueryBuilder.aggregate({ filter }, aggregate);
+    const qb = this.filterQueryBuilder.aggregate({
+      filter
+    }, aggregate);
     await qb.applyFilters();
     const rawResults = await qb.execute();
     return AggregateBuilder.convertToAggregateResponse(rawResults);
   }
   async count(filter) {
-    const qb = this.filterQueryBuilder.select({ filter });
+    const qb = this.filterQueryBuilder.select({
+      filter
+    });
     await qb.applyFilters();
     return qb.getCount();
   }
   /**
-   * Find an entity by it's `id`.
-   *
-   * @example
-   * ```ts
-   * const todoItem = await this.service.findById(1);
-   * ```
-   * @param id - The id of the record to find.
-   */
+  * Find an entity by it's `id`.
+  *
+  * @example
+  * ```ts
+  * const todoItem = await this.service.findById(1);
+  * ```
+  * @param id - The id of the record to find.
+  */
   async findById(id, opts) {
     const qb = this.filterQueryBuilder.selectById(id, opts ?? {});
     await qb.applyFilters();
@@ -1285,113 +1413,119 @@ var MikroOrmQueryService = class extends RelationQueryService {
     return result ?? void 0;
   }
   /**
-   * Gets an entity by it's `id`. If the entity is not found a rejected promise is returned.
-   *
-   * @example
-   * ```ts
-   * try {
-   *   const todoItem = await this.service.getById(1);
-   * } catch(e) {
-   *   console.error('Unable to find entity with id = 1');
-   * }
-   * ```
-   * @param id - The id of the record to find.
-   */
+  * Gets an entity by it's `id`. If the entity is not found a rejected promise is returned.
+  *
+  * @example
+  * ```ts
+  * try {
+  *   const todoItem = await this.service.getById(1);
+  * } catch(e) {
+  *   console.error('Unable to find entity with id = 1');
+  * }
+  * ```
+  * @param id - The id of the record to find.
+  */
   async getById(id, opts) {
     const entity = await this.findById(id, opts);
     if (!entity) {
-      throw new import_common2.NotFoundException(`Unable to find ${this.EntityClass.name} with id: ${id}`);
+      throw new common.NotFoundException(`Unable to find ${this.EntityClass.name} with id: ${id}`);
     }
     return entity;
   }
   /**
-   * Creates a single entity.
-   *
-   * @example
-   * ```ts
-   * const todoItem = await this.service.createOne({title: 'Todo Item', completed: false });
-   * ```
-   * @param record - The entity to create.
-   */
+  * Creates a single entity.
+  *
+  * @example
+  * ```ts
+  * const todoItem = await this.service.createOne({title: 'Todo Item', completed: false });
+  * ```
+  * @param record - The entity to create.
+  */
   async createOne(record) {
     const entity = await this.ensureIsEntityAndDoesNotExist(record);
     await this.repo.getEntityManager().persist(entity).flush();
     return entity;
   }
   /**
-   * Create multiple entities.
-   *
-   * @example
-   * ```ts
-   * const todoItem = await this.service.createMany([
-   *   {title: 'Todo Item 1', completed: false },
-   *   {title: 'Todo Item 2', completed: true },
-   * ]);
-   * ```
-   * @param records - The entities to create.
-   */
+  * Create multiple entities.
+  *
+  * @example
+  * ```ts
+  * const todoItem = await this.service.createMany([
+  *   {title: 'Todo Item 1', completed: false },
+  *   {title: 'Todo Item 2', completed: true },
+  * ]);
+  * ```
+  * @param records - The entities to create.
+  */
   async createMany(records) {
     const entities = await Promise.all(records.map((r) => this.ensureIsEntityAndDoesNotExist(r)));
     await this.repo.getEntityManager().persist(entities).flush();
     return entities;
   }
   /**
-   * Update an entity.
-   *
-   * @example
-   * ```ts
-   * const updatedEntity = await this.service.updateOne(1, { completed: true });
-   * ```
-   * @param id - The `id` of the record.
-   * @param update - A `Partial` of the entity with fields to update.
-   * @param opts - Additional options.
-   */
+  * Update an entity.
+  *
+  * @example
+  * ```ts
+  * const updatedEntity = await this.service.updateOne(1, { completed: true });
+  * ```
+  * @param id - The `id` of the record.
+  * @param update - A `Partial` of the entity with fields to update.
+  * @param opts - Additional options.
+  */
   async updateOne(id, update, opts) {
     this.ensureIdIsNotPresent(update);
     const entity = await this.getById(id, opts);
-    (0, import_core5.wrap)(entity).assign(update);
+    core.wrap(entity).assign(update);
     await this.repo.getEntityManager().flush();
     return entity;
   }
   /**
-   * Update multiple entities with a `@nestjs-query/core` Filter.
-   *
-   * @example
-   * ```ts
-   * const { updatedCount } = await this.service.updateMany(
-   *   { completed: true }, // the update to apply
-   *   { title: { eq: 'Foo Title' } } // Filter to find records to update
-   * );
-   * ```
-   * @param update - A `Partial` of entity with the fields to update
-   * @param filter - A Filter used to find the records to update
-   */
+  * Update multiple entities with a `@nestjs-query/core` Filter.
+  *
+  * @example
+  * ```ts
+  * const { updatedCount } = await this.service.updateMany(
+  *   { completed: true }, // the update to apply
+  *   { title: { eq: 'Foo Title' } } // Filter to find records to update
+  * );
+  * ```
+  * @param update - A `Partial` of entity with the fields to update
+  * @param filter - A Filter used to find the records to update
+  */
   async updateMany(update, filter) {
     this.ensureIdIsNotPresent(update);
-    const entities = await this.query({ filter });
+    const entities = await this.query({
+      filter
+    });
     for (const entity of entities) {
-      (0, import_core5.wrap)(entity).assign(update);
+      core.wrap(entity).assign(update);
     }
     await this.repo.getEntityManager().flush();
-    return { updatedCount: entities.length };
+    return {
+      updatedCount: entities.length
+    };
   }
   /**
-   * Delete an entity by `id`.
-   *
-   * @example
-   *
-   * ```ts
-   * const deletedTodo = await this.service.deleteOne(1);
-   * ```
-   *
-   * @param id - The `id` of the entity to delete.
-   * @param filter Additional filter to use when finding the entity to delete.
-   */
+  * Delete an entity by `id`.
+  *
+  * @example
+  *
+  * ```ts
+  * const deletedTodo = await this.service.deleteOne(1);
+  * ```
+  *
+  * @param id - The `id` of the entity to delete.
+  * @param filter Additional filter to use when finding the entity to delete.
+  */
   async deleteOne(id, opts) {
     const entity = await this.getById(id, opts);
     const em = this.repo.getEntityManager();
     if (this.useSoftDelete) {
-      (0, import_core5.wrap)(entity).assign({ deletedAt: /* @__PURE__ */ new Date() });
+      core.wrap(entity).assign({
+        deletedAt: /* @__PURE__ */ new Date()
+      });
       await em.flush();
     } else {
       await em.remove(entity).flush();
@@ -1402,24 +1536,28 @@ var MikroOrmQueryService = class extends RelationQueryService {
     return entity;
   }
   /**
-   * Delete multiple records with a `@nestjs-query/core` `Filter`.
-   *
-   * @example
-   *
-   * ```ts
-   * const { deletedCount } = this.service.deleteMany({
-   *   created: { lte: new Date('2020-1-1') }
-   * });
-   * ```
-   *
-   * @param filter - A `Filter` to find records to delete.
-   */
+  * Delete multiple records with a `@nestjs-query/core` `Filter`.
+  *
+  * @example
+  *
+  * ```ts
+  * const { deletedCount } = this.service.deleteMany({
+  *   created: { lte: new Date('2020-1-1') }
+  * });
+  * ```
+  *
+  * @param filter - A `Filter` to find records to delete.
+  */
   async deleteMany(filter) {
-    const entities = await this.query({ filter });
+    const entities = await this.query({
+      filter
+    });
     const em = this.repo.getEntityManager();
     if (this.useSoftDelete) {
       for (const entity of entities) {
-        (0, import_core5.wrap)(entity).assign({ deletedAt: /* @__PURE__ */ new Date() });
+        core.wrap(entity).assign({
+          deletedAt: /* @__PURE__ */ new Date()
+        });
       }
     } else {
       for (const entity of entities) {
@@ -1427,20 +1565,22 @@ var MikroOrmQueryService = class extends RelationQueryService {
       }
     }
     await em.flush();
-    return { deletedCount: entities.length };
+    return {
+      deletedCount: entities.length
+    };
   }
   /**
-   * Restore an entity by `id`.
-   *
-   * @example
-   *
-   * ```ts
-   * const restoredTodo = await this.service.restoreOne(1);
-   * ```
-   *
-   * @param id - The `id` of the entity to restore.
-   * @param opts Additional filter to use when finding the entity to restore.
-   */
+  * Restore an entity by `id`.
+  *
+  * @example
+  *
+  * ```ts
+  * const restoredTodo = await this.service.restoreOne(1);
+  * ```
+  *
+  * @param id - The `id` of the entity to restore.
+  * @param opts Additional filter to use when finding the entity to restore.
+  */
   async restoreOne(id, opts) {
     this.ensureSoftDeleteEnabled();
     const em = this.repo.getEntityManager();
@@ -1453,32 +1593,37 @@ var MikroOrmQueryService = class extends RelationQueryService {
       const whereBuilder = new WhereBuilder();
       const additionalWhere = whereBuilder.build(opts.filter);
       whereClause = {
-        $and: [whereClause, additionalWhere]
+        $and: [
+          whereClause,
+          additionalWhere
+        ]
       };
     }
     const entity = await em.findOne(this.EntityClass, whereClause, {
       filters: false
     });
     if (!entity) {
-      throw new import_common2.NotFoundException(`Unable to find ${this.EntityClass.name} with id: ${id}`);
+      throw new common.NotFoundException(`Unable to find ${this.EntityClass.name} with id: ${id}`);
     }
-    (0, import_core5.wrap)(entity).assign({ deletedAt: null });
+    core.wrap(entity).assign({
+      deletedAt: null
+    });
     await em.flush();
     return entity;
   }
   /**
-   * Restores multiple records with a `@nestjs-query/core` `Filter`.
-   *
-   * @example
-   *
-   * ```ts
-   * const { updatedCount } = this.service.restoreMany({
-   *   created: { lte: new Date('2020-1-1') }
-   * });
-   * ```
-   *
-   * @param filter - A `Filter` to find records to restore.
-   */
+  * Restores multiple records with a `@nestjs-query/core` `Filter`.
+  *
+  * @example
+  *
+  * ```ts
+  * const { updatedCount } = this.service.restoreMany({
+  *   created: { lte: new Date('2020-1-1') }
+  * });
+  * ```
+  *
+  * @param filter - A `Filter` to find records to restore.
+  */
   async restoreMany(filter) {
     this.ensureSoftDeleteEnabled();
     const em = this.repo.getEntityManager();
@@ -1488,10 +1633,14 @@ var MikroOrmQueryService = class extends RelationQueryService {
       filters: false
     });
     for (const entity of entities) {
-      (0, import_core5.wrap)(entity).assign({ deletedAt: null });
+      core.wrap(entity).assign({
+        deletedAt: null
+      });
     }
     await em.flush();
-    return { updatedCount: entities.length };
+    return {
+      updatedCount: entities.length
+    };
   }
   get em() {
     return this.repo.getEntityManager();
@@ -1527,9 +1676,7 @@ var MikroOrmQueryService = class extends RelationQueryService {
   }
   ensureSoftDeleteEnabled() {
     if (!this.useSoftDelete) {
-      throw new import_common2.MethodNotAllowedException(
-        `Restore not allowed for non soft deleted entity ${this.EntityClass.name}.`
-      );
+      throw new common.MethodNotAllowedException(`Restore not allowed for non soft deleted entity ${this.EntityClass.name}.`);
     }
   }
 };
@@ -1538,38 +1685,50 @@ var MikroOrmQueryService = class extends RelationQueryService {
 function createMikroOrmQueryServiceProvider(EntityClass, contextName) {
   return {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    provide: (0, import_core7.getQueryServiceToken)(EntityClass),
+    provide: core$1.getQueryServiceToken(EntityClass),
     useFactory(repo) {
       return new MikroOrmQueryService(repo);
     },
-    inject: [(0, import_nestjs.getRepositoryToken)(EntityClass, contextName)]
+    inject: [
+      nestjs.getRepositoryToken(EntityClass, contextName)
+    ]
   };
 }
-var createMikroOrmQueryServiceProviders = (entities, contextName) => entities.map((entity) => createMikroOrmQueryServiceProvider(entity, contextName));
+__name(createMikroOrmQueryServiceProvider, "createMikroOrmQueryServiceProvider");
+var createMikroOrmQueryServiceProviders = /* @__PURE__ */ __name((entities, contextName) => entities.map((entity) => createMikroOrmQueryServiceProvider(entity, contextName)), "createMikroOrmQueryServiceProviders");
 
 // src/lib/nest-query-mikro-orm.module.ts
 var NestjsQueryMikroOrmModule = class _NestjsQueryMikroOrmModule {
+  static {
+    __name(this, "NestjsQueryMikroOrmModule");
+  }
   static forFeature(entities, contextName) {
     const queryServiceProviders = createMikroOrmQueryServiceProviders(entities, contextName);
-    const mikroOrmModule = import_nestjs2.MikroOrmModule.forFeature(entities, contextName);
+    const mikroOrmModule = nestjs.MikroOrmModule.forFeature(entities, contextName);
     return {
-      imports: [mikroOrmModule],
+      imports: [
+        mikroOrmModule
+      ],
       module: _NestjsQueryMikroOrmModule,
-      providers: [...queryServiceProviders],
-      exports: [...queryServiceProviders, mikroOrmModule]
+      providers: [
+        ...queryServiceProviders
+      ],
+      exports: [
+        ...queryServiceProviders,
+        mikroOrmModule
+      ]
     };
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AggregateBuilder,
-  FilterQueryBuilder,
-  MikroOrmQueryService,
-  NestjsQueryMikroOrmModule,
-  RelationQueryBuilder,
-  RelationQueryService,
-  SQLComparisonBuilder,
-  WhereBuilder,
-  createMikroOrmQueryServiceProviders
-});
+
+exports.AggregateBuilder = AggregateBuilder;
+exports.FilterQueryBuilder = FilterQueryBuilder;
+exports.MikroOrmQueryService = MikroOrmQueryService;
+exports.NestjsQueryMikroOrmModule = NestjsQueryMikroOrmModule;
+exports.RelationQueryBuilder = RelationQueryBuilder;
+exports.RelationQueryService = RelationQueryService;
+exports.SQLComparisonBuilder = SQLComparisonBuilder;
+exports.WhereBuilder = WhereBuilder;
+exports.createMikroOrmQueryServiceProviders = createMikroOrmQueryServiceProviders;
 //# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map