nestjs-query-mikro-orm 0.1.4 → 0.1.5

package/dist/index.mjs

@@ -654,53 +654,81 @@ var RelationQueryBuilder = class {
     this.filterQueryBuilder = new FilterQueryBuilder(relationRepo);
   }
   /**
-  * Executes a relation select using `em.find` so the implementation is database-agnostic.
+  * Executes a relation select using MikroORM native relation population first.
   */
-  async selectAndExecute(entity, query) {
-    const relationMeta = this.getRelationMeta();
+  async selectAndExecute(entity, query, loadOptions) {
+    const nativeRelations = await this.tryLoadRelationsNatively(entity, loadOptions?.useDataloader, loadOptions?.strategy);
+    if (!nativeRelations) {
+      return this.queryByOwnerCondition(entity, query);
+    }
+    const resolvedRelations = nativeRelations;
+    if (!this.hasFilterSortingOrPaging(query)) {
+      return resolvedRelations;
+    }
+    if (!this.hasFilterOrSorting(query)) {
+      return this.applyPaging(resolvedRelations, query);
+    }
+    return this.queryResolvedRelations(resolvedRelations, query);
+  }
+  async batchSelectAndExecute(entities, query, loadOptions) {
+    if (entities.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const nativeRelationsMap = await this.tryBatchLoadRelationsNatively(entities, loadOptions?.useDataloader, loadOptions?.strategy);
+    if (!nativeRelationsMap) {
+      const results2 = /* @__PURE__ */ new Map();
+      await Promise.all(entities.map(async (entity) => {
+        const relations = await this.queryByOwnerCondition(entity, query);
+        if (relations.length > 0) {
+          results2.set(entity, relations);
+        }
+      }));
+      return results2;
+    }
+    if (!this.hasFilterSortingOrPaging(query)) {
+      return nativeRelationsMap;
+    }
+    if (!this.hasFilterOrSorting(query)) {
+      return this.applyPagingToMap(nativeRelationsMap, query);
+    }
+    const results = /* @__PURE__ */ new Map();
+    await Promise.all(entities.map(async (entity) => {
+      const relations = nativeRelationsMap.get(entity) ?? [];
+      const queried = await this.queryResolvedRelations(relations, query);
+      if (queried.length > 0) {
+        results.set(entity, queried);
+      }
+    }));
+    return results;
+  }
+  async populateEntityRelation(entity, useDataloader, strategy) {
     const em = this.repo.getEntityManager();
-    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);
+    const emPopulate = em;
+    try {
+      await emPopulate.populate([
+        entity
+      ], [
+        this.relation
+      ], this.getNativePopulateOptions(useDataloader, strategy));
+      return true;
+    } catch {
+      return false;
+    }
   }
   async count(entity, query) {
-    const relationMeta = this.getRelationMeta();
-    const em = this.repo.getEntityManager();
-    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);
+    const relations = await this.selectAndExecute(entity, {
+      ...query,
+      paging: void 0,
+      sorting: void 0
+    });
+    return relations.length;
   }
   async aggregate(entity, query, aggregateQuery) {
-    const relationMeta = this.getRelationMeta();
-    const em = this.repo.getEntityManager();
-    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 rows = await this.selectAndExecute(entity, {
+      ...query,
+      paging: void 0,
+      sorting: void 0
+    });
     const aggs = aggregateQuery;
     const groupBy = aggs.groupBy ?? [];
     const makeAggKey = /* @__PURE__ */ __name((func, field) => `${func}_${field}`, "makeAggKey");
@@ -811,6 +839,259 @@ var RelationQueryBuilder = class {
     }
     return records;
   }
+  getRelationMeta() {
+    const em = this.repo.getEntityManager();
+    const metadata = em.getMetadata().get(this.repo.getEntityName());
+    const relationProp = metadata.properties[this.relation];
+    if (!relationProp) {
+      throw new Error(`Unable to find relation '${this.relation}' on entity`);
+    }
+    return relationProp;
+  }
+  get entityIndexColName() {
+    return "__nestjsQuery__entityIndex__";
+  }
+  getRelationPrimaryKeysPropertyNameAndColumnsName() {
+    const em = this.repo.getEntityManager();
+    const relationMeta = this.getRelationMeta();
+    const relationEntityMeta = em.getMetadata().get(relationMeta.type);
+    return relationEntityMeta.primaryKeys.map((pk) => {
+      const prop = relationEntityMeta.properties[pk];
+      return {
+        propertyName: pk,
+        columnName: prop.fieldNames?.[0] || pk
+      };
+    });
+  }
+  getNativeLoadOptions(useDataloader = false) {
+    if (!useDataloader) {
+      return void 0;
+    }
+    return {
+      dataloader: true
+    };
+  }
+  getNativePopulateOptions(useDataloader = false, strategy) {
+    const nativeLoadOptions = this.getNativeLoadOptions(useDataloader);
+    const options = {};
+    if (nativeLoadOptions) {
+      options.dataloader = true;
+    }
+    if (strategy) {
+      options.strategy = strategy;
+    }
+    if (!Object.keys(options).length) {
+      return void 0;
+    }
+    return options;
+  }
+  async tryBatchLoadRelationsNatively(entities, useDataloader = false, strategy) {
+    const em = this.repo.getEntityManager();
+    const entityName = this.repo.getEntityName();
+    const metadata = em.getMetadata().get(entityName);
+    const primaryKey = metadata.primaryKeys[0];
+    const entityAndIds = entities.map((entity) => {
+      const id = entity[primaryKey];
+      return [
+        entity,
+        id
+      ];
+    });
+    const ids = entityAndIds.map(([, id]) => id).filter((id) => id !== void 0 && id !== null);
+    if (!ids.length) {
+      return /* @__PURE__ */ new Map();
+    }
+    const where = {
+      [primaryKey]: {
+        $in: ids
+      }
+    };
+    const findOptions = {
+      ...this.getNativePopulateOptions(useDataloader, strategy) ?? {},
+      populate: [
+        this.relation
+      ]
+    };
+    let populatedEntities;
+    try {
+      populatedEntities = await em.find(entityName, where, findOptions);
+    } catch {
+      return void 0;
+    }
+    const relationMeta = this.getRelationMeta();
+    const relationsMap = /* @__PURE__ */ new Map();
+    const populatedById = /* @__PURE__ */ new Map();
+    populatedEntities.forEach((populatedEntity) => {
+      const id = populatedEntity[primaryKey];
+      if (id !== void 0 && id !== null) {
+        populatedById.set(this.serializePrimaryKeyValue(id), populatedEntity);
+      }
+    });
+    for (const [entity, id] of entityAndIds) {
+      if (id === void 0 || id === null) {
+        relationsMap.set(entity, []);
+        continue;
+      }
+      const resolvedEntity = populatedById.get(this.serializePrimaryKeyValue(id));
+      if (!resolvedEntity) {
+        relationsMap.set(entity, []);
+        continue;
+      }
+      const relations = this.readLoadedRelation(resolvedEntity, relationMeta);
+      if (relations === void 0) {
+        return void 0;
+      }
+      relationsMap.set(entity, relations);
+    }
+    return relationsMap;
+  }
+  async tryLoadRelationsNatively(entity, useDataloader = false, strategy) {
+    const relationsMap = await this.tryBatchLoadRelationsNatively([
+      entity
+    ], useDataloader, strategy);
+    if (!relationsMap) {
+      return void 0;
+    }
+    return relationsMap.get(entity) ?? [];
+  }
+  readLoadedRelation(entity, relationMeta) {
+    const entityRecord = entity;
+    const propsRecord = entityRecord.props;
+    const relationValue = entityRecord[this.relation] !== void 0 ? entityRecord[this.relation] : propsRecord?.[this.relation];
+    if (relationMeta.kind === "1:m" || relationMeta.kind === "m:n") {
+      if (!relationValue || typeof relationValue !== "object") {
+        return void 0;
+      }
+      const maybeCollection = relationValue;
+      if (typeof maybeCollection.getItems === "function") {
+        return maybeCollection.getItems(false);
+      }
+      if (Array.isArray(relationValue)) {
+        return relationValue;
+      }
+      return void 0;
+    }
+    if (relationValue === null || relationValue === void 0) {
+      return [];
+    }
+    if (typeof relationValue !== "object") {
+      return void 0;
+    }
+    const maybeReference = relationValue;
+    if (maybeReference.$ !== void 0) {
+      return maybeReference.$ === null ? [] : [
+        maybeReference.$
+      ];
+    }
+    if (typeof maybeReference.get === "function") {
+      try {
+        const loaded = maybeReference.get();
+        return loaded === null || loaded === void 0 ? [] : [
+          loaded
+        ];
+      } catch {
+        return void 0;
+      }
+    }
+    if (typeof maybeReference.getEntity === "function") {
+      try {
+        const loaded = maybeReference.getEntity();
+        return loaded === null || loaded === void 0 ? [] : [
+          loaded
+        ];
+      } catch {
+        return void 0;
+      }
+    }
+    if (typeof maybeReference.unwrap === "function") {
+      const loaded = maybeReference.unwrap();
+      return loaded === null || loaded === void 0 ? [] : [
+        loaded
+      ];
+    }
+    return [
+      relationValue
+    ];
+  }
+  applyPaging(relations, query) {
+    const limit = query.paging?.limit;
+    const offset = query.paging?.offset ?? 0;
+    if (limit === void 0 && offset === 0) {
+      return relations;
+    }
+    if (limit === void 0) {
+      return relations.slice(offset);
+    }
+    return relations.slice(offset, offset + limit);
+  }
+  applyPagingToMap(relationsMap, query) {
+    const mapped = /* @__PURE__ */ new Map();
+    for (const [entity, relations] of relationsMap.entries()) {
+      const paged = this.applyPaging(relations, query);
+      if (paged.length > 0) {
+        mapped.set(entity, paged);
+      }
+    }
+    return mapped;
+  }
+  serializePrimaryKeyValue(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+  }
+  hasFilterSortingOrPaging(query) {
+    return this.hasFilterOrSorting(query) || Boolean(query.paging?.limit || query.paging?.offset);
+  }
+  hasFilterOrSorting(query) {
+    return Boolean(query.sorting?.length) || Boolean(query.filter && Object.keys(query.filter).length);
+  }
+  async queryResolvedRelations(resolvedRelations, query) {
+    if (resolvedRelations.length === 0) {
+      return [];
+    }
+    const em = this.repo.getEntityManager();
+    const relationMeta = this.getRelationMeta();
+    const RelationEntity = relationMeta.type;
+    const metadata = em.getMetadata().get(RelationEntity);
+    const primaryKey = metadata.primaryKeys[0];
+    const ids = resolvedRelations.map((r) => r[primaryKey]).filter((v) => v !== void 0 && v !== null);
+    if (!ids.length) {
+      return [];
+    }
+    const idFilter = {
+      [primaryKey]: {
+        $in: ids
+      }
+    };
+    const { filterQuery, options } = this.filterQueryBuilder.buildFindOptions(query);
+    const finalWhere = filterQuery ? {
+      $and: [
+        idFilter,
+        filterQuery
+      ]
+    } : idFilter;
+    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 em.find(RelationEntity, finalWhere, findOptions);
+  }
+  async queryByOwnerCondition(entity, query) {
+    const relationMeta = this.getRelationMeta();
+    const em = this.repo.getEntityManager();
+    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 em.find(RelationEntity, finalWhere, findOptions);
+  }
   buildWhereCondition(entity, relationMeta) {
     const em = this.repo.getEntityManager();
     const entityMeta = em.getMetadata().get(this.repo.getEntityName());
@@ -882,16 +1163,14 @@ var RelationQueryBuilder = class {
         return {
           [relationPrimaryKey]: fkValue
         };
-      } else {
-        return {
-          [relationMeta.mappedBy]: entityId
-        };
       }
+      return {
+        [relationMeta.mappedBy]: entityId
+      };
     }
     if (relationMeta.kind === "1:m") {
-      const mappedBy = relationMeta.mappedBy;
       return {
-        [mappedBy]: entityId
+        [relationMeta.mappedBy]: entityId
       };
     }
     if (relationMeta.kind === "m:n") {
@@ -899,40 +1178,15 @@ var RelationQueryBuilder = class {
         return {
           [relationMeta.inversedBy]: entityId
         };
-      } else {
-        return {
-          [relationMeta.mappedBy]: entityId
-        };
       }
+      return {
+        [relationMeta.mappedBy]: entityId
+      };
     }
     return {
       [entityPrimaryKey]: entityId
     };
   }
-  getRelationMeta() {
-    const em = this.repo.getEntityManager();
-    const metadata = em.getMetadata().get(this.repo.getEntityName());
-    const relationProp = metadata.properties[this.relation];
-    if (!relationProp) {
-      throw new Error(`Unable to find relation '${this.relation}' on entity`);
-    }
-    return relationProp;
-  }
-  get entityIndexColName() {
-    return "__nestjsQuery__entityIndex__";
-  }
-  getRelationPrimaryKeysPropertyNameAndColumnsName() {
-    const em = this.repo.getEntityManager();
-    const relationMeta = this.getRelationMeta();
-    const relationEntityMeta = em.getMetadata().get(relationMeta.type);
-    return relationEntityMeta.primaryKeys.map((pk) => {
-      const prop = relationEntityMeta.properties[pk];
-      return {
-        propertyName: pk,
-        columnName: prop.fieldNames?.[0] || pk
-      };
-    });
-  }
 };
 var AGG_REGEXP = /^(AVG|SUM|COUNT|MAX|MIN|GROUP_BY|group_by|groupBy|avg|sum|count|max|min)_(.*)$/i;
 var AggregateBuilder = class _AggregateBuilder {
@@ -1171,17 +1425,25 @@ var RelationQueryService = class {
   static {
     __name(this, "RelationQueryService");
   }
+  relationLoadingStrategy;
+  nativeLoadUseDataloader;
+  constructor(opts) {
+    this.relationLoadingStrategy = opts?.relationLoading?.strategy;
+    this.nativeLoadUseDataloader = opts?.relationLoading?.useDataloader ?? false;
+  }
   async queryRelations(RelationClass, relationName, dto, query) {
     if (Array.isArray(dto)) {
       return this.batchQueryRelations(RelationClass, relationName, dto, query);
     }
-    if (this.isRelationClassIdentity(RelationClass, relationName)) {
-      const relationQueryBuilder2 = this.getRelationQueryBuilder(relationName);
-      return await relationQueryBuilder2.selectAndExecute(dto, query);
-    }
-    const assembler = AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
+    const bypassAssembler = this.isRelationClassIdentity(RelationClass, relationName);
+    const assembler = bypassAssembler ? void 0 : AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
+    const convertedQuery = assembler ? assembler.convertQuery(query) : query;
     const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
-    return assembler.convertToDTOs(await relationQueryBuilder.selectAndExecute(dto, assembler.convertQuery(query)));
+    const relations = await relationQueryBuilder.selectAndExecute(dto, convertedQuery, this.getRelationLoadOptions());
+    if (bypassAssembler) {
+      return relations;
+    }
+    return assembler.convertToDTOs(relations);
   }
   async aggregateRelations(RelationClass, relationName, dto, filter, aggregate) {
     if (Array.isArray(dto)) {
@@ -1219,7 +1481,7 @@ var RelationQueryService = class {
         paging: {
           limit: 1
         }
-      });
+      }, this.getRelationLoadOptions());
       return relations2[0];
     }
     const assembler = AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
@@ -1229,7 +1491,7 @@ var RelationQueryService = class {
       paging: {
         limit: 1
       }
-    });
+    }, this.getRelationLoadOptions());
     const relationEntity = relations[0];
     return relationEntity ? assembler.convertToDTO(relationEntity) : void 0;
   }
@@ -1247,19 +1509,24 @@ var RelationQueryService = class {
     if (!this.foundAllRelations(relationIds, relations)) {
       throw new Error(`Unable to find all ${relationName} to add to ${this.EntityClass.name}`);
     }
-    if (meta.kind === "1:m" && meta.mappedBy) {
+    const collection = entity[relationName];
+    if (collection && typeof collection.add === "function") {
+      const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
+      const populated = await relationQueryBuilder.populateEntityRelation(entity, this.nativeLoadUseDataloader, this.relationLoadingStrategy);
+      if (!populated) {
+        await collection.init();
+      }
       for (const relation of relations) {
-        wrap(relation).assign({
-          [meta.mappedBy]: entity
-        });
+        collection.add(relation);
       }
       await this.repo.getEntityManager().flush();
       return entity;
     }
-    const collection = entity[relationName];
-    if (collection && typeof collection.add === "function") {
+    if (meta.kind === "1:m" && meta.mappedBy) {
       for (const relation of relations) {
-        collection.add(relation);
+        wrap(relation).assign({
+          [meta.mappedBy]: entity
+        });
       }
       await this.repo.getEntityManager().flush();
     }
@@ -1283,9 +1550,20 @@ var RelationQueryService = class {
         throw new Error(`Unable to find all ${relationName} to set on ${this.EntityClass.name}`);
       }
     }
+    const collection = entity[relationName];
+    if (collection && typeof collection.set === "function") {
+      const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
+      const populated = await relationQueryBuilder.populateEntityRelation(entity, this.nativeLoadUseDataloader, this.relationLoadingStrategy);
+      if (!populated) {
+        await collection.init();
+      }
+      collection.set(relations);
+      await this.repo.getEntityManager().flush();
+      return entity;
+    }
     if (meta.kind === "1:m" && meta.mappedBy) {
       const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
-      const currentRelations = await relationQueryBuilder.selectAndExecute(entity, {});
+      const currentRelations = await relationQueryBuilder.selectAndExecute(entity, {}, this.getRelationLoadOptions());
       const nextSet = new Set(relations.map((r) => wrap(r).getPrimaryKey()));
       for (const currentRelation of currentRelations) {
         const currentPk = wrap(currentRelation).getPrimaryKey();
@@ -1301,13 +1579,6 @@ var RelationQueryService = class {
         });
       }
       await this.repo.getEntityManager().flush();
-      return entity;
-    }
-    const collection = entity[relationName];
-    if (collection && typeof collection.set === "function") {
-      await collection.init();
-      collection.set(relations);
-      await this.repo.getEntityManager().flush();
     }
     return entity;
   }
@@ -1347,20 +1618,24 @@ var RelationQueryService = class {
     if (!this.foundAllRelations(relationIds, relations)) {
       throw new Error(`Unable to find all ${relationName} to remove from ${this.EntityClass.name}`);
     }
-    if (meta.kind === "1:m" && meta.mappedBy) {
+    const collection = entity[relationName];
+    if (collection && typeof collection.remove === "function") {
+      const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
+      const populated = await relationQueryBuilder.populateEntityRelation(entity, this.nativeLoadUseDataloader, this.relationLoadingStrategy);
+      if (!populated) {
+        await collection.init();
+      }
       for (const relation of relations) {
-        wrap(relation).assign({
-          [meta.mappedBy]: null
-        });
+        collection.remove(relation);
       }
       await this.repo.getEntityManager().flush();
       return entity;
     }
-    const collection = entity[relationName];
-    if (collection && typeof collection.remove === "function") {
-      await collection.init();
+    if (meta.kind === "1:m" && meta.mappedBy) {
       for (const relation of relations) {
-        collection.remove(relation);
+        wrap(relation).assign({
+          [meta.mappedBy]: null
+        });
       }
       await this.repo.getEntityManager().flush();
     }
@@ -1384,29 +1659,30 @@ var RelationQueryService = class {
     const meta = this.getRelationMeta(relationName);
     if (meta.kind === "1:1" || meta.kind === "m:1") {
       const fkFieldName = `${relationName}Id`;
-      const assignData = {};
+      const assignData = {
+        [relationName]: null
+      };
       const ownDescriptor = Object.getOwnPropertyDescriptor(entity, fkFieldName);
       const protoDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(entity), fkFieldName);
       const descriptor = ownDescriptor ?? protoDescriptor;
       const canAssignFk = fkFieldName in entity && (!descriptor || Boolean(descriptor.set) || descriptor.writable === true);
       if (canAssignFk) {
         assignData[fkFieldName] = null;
-      } else {
-        assignData[relationName] = null;
       }
       wrap(entity).assign(assignData);
     } else {
-      if (meta.kind === "1:m" && meta.mappedBy) {
-        wrap(relation).assign({
-          [meta.mappedBy]: null
-        });
-        await this.repo.getEntityManager().flush();
-        return entity;
-      }
       const collection = entity[relationName];
       if (collection && typeof collection.remove === "function") {
-        await collection.init();
+        const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
+        const populated = await relationQueryBuilder.populateEntityRelation(entity, this.nativeLoadUseDataloader, this.relationLoadingStrategy);
+        if (!populated) {
+          await collection.init();
+        }
         collection.remove(relation);
+      } else if (meta.kind === "1:m" && meta.mappedBy) {
+        wrap(relation).assign({
+          [meta.mappedBy]: null
+        });
       }
     }
     await this.repo.getEntityManager().flush();
@@ -1427,15 +1703,18 @@ var RelationQueryService = class {
     const assembler = bypassAssembler ? void 0 : AssemblerFactory.getAssembler(RelationClass, this.getRelationEntity(relationName));
     const relationQueryBuilder = this.getRelationQueryBuilder(relationName);
     const convertedQuery = assembler ? assembler.convertQuery(query) : query;
-    const results = /* @__PURE__ */ new Map();
-    await Promise.all(entities.map(async (entity) => {
-      const relations = await relationQueryBuilder.selectAndExecute(entity, convertedQuery);
-      const relationDtos = bypassAssembler ? relations : await assembler.convertToDTOs(relations);
+    const relationsMap = await relationQueryBuilder.batchSelectAndExecute(entities, convertedQuery, this.getRelationLoadOptions());
+    if (bypassAssembler) {
+      return relationsMap;
+    }
+    const dtoMap = /* @__PURE__ */ new Map();
+    for (const [entity, relations] of relationsMap.entries()) {
+      const relationDtos = await assembler.convertToDTOs(relations);
       if (relationDtos.length > 0) {
-        results.set(entity, relationDtos);
+        dtoMap.set(entity, relationDtos);
       }
-    }));
-    return results;
+    }
+    return dtoMap;
   }
   /**
   * Query for an array of relations for multiple dtos.
@@ -1504,6 +1783,12 @@ var RelationQueryService = class {
     const relationEntity = this.getRelationEntity(relationName);
     return RelationClass === relationEntity || RelationClass.name === relationEntity.name;
   }
+  getRelationLoadOptions() {
+    return {
+      strategy: this.relationLoadingStrategy,
+      useDataloader: this.nativeLoadUseDataloader
+    };
+  }
   getRelationMeta(relationName) {
     const em = this.repo.getEntityManager();
     const metadata = em.getMetadata().get(this.repo.getEntityName());
@@ -1562,7 +1847,9 @@ var MikroOrmQueryService = class extends RelationQueryService {
   filterQueryBuilder;
   useSoftDelete;
   constructor(repo, opts) {
-    super(), this.repo = repo;
+    super({
+      relationLoading: opts?.relationLoading
+    }), this.repo = repo;
     this.filterQueryBuilder = opts?.filterQueryBuilder ?? new FilterQueryBuilder(this.repo);
     this.useSoftDelete = opts?.useSoftDelete ?? false;
     const serializer = getAssemblerSerializer(this.EntityClass);
@@ -1583,7 +1870,11 @@ var MikroOrmQueryService = class extends RelationQueryService {
         return data;
       })(this.EntityClass);
       AssemblerDeserializer((d) => {
-        const entity = this.repo.getEntityManager().merge(this.EntityClass, d);
+        const entity = this.repo.getEntityManager().create(this.EntityClass, d, {
+          managed: true,
+          convertCustomTypes: true,
+          partial: true
+        });
         return entity;
       })(this.EntityClass);
     }
@@ -2080,12 +2371,12 @@ var MikroOrmQueryService = class extends RelationQueryService {
 };
 
 // src/lib/providers.ts
-function createMikroOrmQueryServiceProvider(EntityClass, contextName) {
+function createMikroOrmQueryServiceProvider(EntityClass, contextName, opts) {
   return {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     provide: getQueryServiceToken(EntityClass),
     useFactory(repo) {
-      return new MikroOrmQueryService(repo);
+      return new MikroOrmQueryService(repo, opts);
     },
     inject: [
       getRepositoryToken(EntityClass, contextName)
@@ -2093,15 +2384,17 @@ function createMikroOrmQueryServiceProvider(EntityClass, contextName) {
   };
 }
 __name(createMikroOrmQueryServiceProvider, "createMikroOrmQueryServiceProvider");
-var createMikroOrmQueryServiceProviders = /* @__PURE__ */ __name((entities, contextName) => entities.map((entity) => createMikroOrmQueryServiceProvider(entity, contextName)), "createMikroOrmQueryServiceProviders");
+var createMikroOrmQueryServiceProviders = /* @__PURE__ */ __name((entities, contextName, opts) => entities.map((entity) => createMikroOrmQueryServiceProvider(entity, contextName, opts)), "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);
+  static forFeature(entities, contextNameOrOptions) {
+    const contextName = typeof contextNameOrOptions === "string" ? contextNameOrOptions : contextNameOrOptions?.contextName;
+    const queryServiceOpts = typeof contextNameOrOptions === "string" ? void 0 : contextNameOrOptions?.queryServiceOpts;
+    const queryServiceProviders = createMikroOrmQueryServiceProviders(entities, contextName, queryServiceOpts);
     const mikroOrmModule = MikroOrmModule.forFeature(entities, contextName);
     return {
       imports: [