diff --git a/packages/core/src/assemblers/assembler.deserializer.ts b/packages/core/src/assemblers/assembler.deserializer.ts
index b8b8253c7..daa715bec 100644
--- a/packages/core/src/assemblers/assembler.deserializer.ts
+++ b/packages/core/src/assemblers/assembler.deserializer.ts
@@ -16,5 +16,5 @@ export function AssemblerDeserializer<T>(deserializer: AssemblerDeserializer<T>)
 }
 
 export function getAssemblerDeserializer<DTO>(DTOClass: Class<DTO>): MetaValue<AssemblerDeserializer<DTO>> {
-  return reflector.get(DTOClass);
+  return reflector.get(DTOClass, true);
 }
diff --git a/packages/core/src/assemblers/assembler.factory.ts b/packages/core/src/assemblers/assembler.factory.ts
index f9b74790a..2167cb3b6 100644
--- a/packages/core/src/assemblers/assembler.factory.ts
+++ b/packages/core/src/assemblers/assembler.factory.ts
@@ -1,21 +1,29 @@
 import { Class, DeepPartial } from '../common';
-import { Assembler, getAssembler } from './assembler';
+import { Assembler, getAssemblers } from './assembler';
 import { DefaultAssembler } from './default.assembler';
 
 /**
  * Assembler Service used by query services to look up Assemblers.
  */
 export class AssemblerFactory {
-  static getAssembler<From, To, C = DeepPartial<From>, CE = DeepPartial<To>, U = C, UE = CE>(
-    FromClass: Class<From>,
-    ToClass: Class<To>,
-  ): Assembler<From, To, C, CE, U, UE> {
-    const AssemblerClass = getAssembler<From, To, C, CE, U, UE>(FromClass, ToClass);
-    if (AssemblerClass) {
-      return new AssemblerClass();
+  static getAssembler<DTO, Entity, C = DeepPartial<DTO>, CE = DeepPartial<Entity>, U = C, UE = CE>(
+    DTOClass: Class<DTO>,
+    EntityClass: Class<Entity>,
+  ): Assembler<DTO, Entity, C, CE, U, UE> {
+    const AssemblerClasses = getAssemblers(DTOClass);
+    if (AssemblerClasses) {
+      const AssemblerClass = AssemblerClasses.get(EntityClass);
+      if (AssemblerClass) {
+        return new AssemblerClass() as Assembler<DTO, Entity, C, CE, U, UE>;
+      }
+      const keys = [...AssemblerClasses.keys()];
+      const keysWithParent = keys.filter((k) => k.prototype instanceof EntityClass);
+      if (keysWithParent.length === 1) {
+        return this.getAssembler(DTOClass, keysWithParent[0] as Class<Entity>);
+      }
     }
-    const defaultAssember = new DefaultAssembler(FromClass, ToClass);
+    const defaultAssembler = new DefaultAssembler(DTOClass, EntityClass);
     // if its a default just assume the types can be converted for all types
-    return (defaultAssember as unknown) as Assembler<From, To, C, CE, U, UE>;
+    return (defaultAssembler as unknown) as Assembler<DTO, Entity, C, CE, U, UE>;
   }
 }
diff --git a/packages/core/src/assemblers/assembler.serializer.ts b/packages/core/src/assemblers/assembler.serializer.ts
index 30dc1d990..414e07d01 100644
--- a/packages/core/src/assemblers/assembler.serializer.ts
+++ b/packages/core/src/assemblers/assembler.serializer.ts
@@ -16,5 +16,5 @@ export function AssemblerSerializer<T>(serializer: AssemblerSerializer<T>) {
 }
 
 export function getAssemblerSerializer<DTO>(DTOClass: Class<DTO>): MetaValue<AssemblerSerializer<DTO>> {
-  return reflector.get(DTOClass);
+  return reflector.get(DTOClass, true);
 }
diff --git a/packages/core/src/assemblers/assembler.ts b/packages/core/src/assemblers/assembler.ts
index cb0517a6c..3d61fd4a5 100644
--- a/packages/core/src/assemblers/assembler.ts
+++ b/packages/core/src/assemblers/assembler.ts
@@ -132,6 +132,12 @@ export function getAssembler<DTO, Entity, C, CE, U, UE>(
   return reflector.get(DTOClass, EntityClass);
 }
 
+export function getAssemblers<DTO>(
+  DTOClass: Class<DTO>,
+): MetaValue<Map<Class<unknown>, Class<Assembler<DTO, unknown, unknown, unknown, unknown, unknown>>>> {
+  return reflector.get(DTOClass);
+}
+
 export function getAssemblerClasses<DTO, Entity, C, CE, U, UE>(
   AssemblerClass: Class<Assembler<DTO, Entity, C, CE, U, UE>>,
 ): MetaValue<AssemblerClasses<DTO, Entity>> {
diff --git a/packages/core/src/assemblers/class-transformer.assembler.ts b/packages/core/src/assemblers/class-transformer.assembler.ts
index fe721749b..584e84f4a 100644
--- a/packages/core/src/assemblers/class-transformer.assembler.ts
+++ b/packages/core/src/assemblers/class-transformer.assembler.ts
@@ -65,6 +65,12 @@ export abstract class ClassTransformerAssembler<DTO, Entity> extends AbstractAss
       if (serializer) {
         return serializer(entityOrDto);
       }
+    } else if ('constructor' in entityOrDto) {
+      // eslint-disable-next-line @typescript-eslint/ban-types
+      const serializer = getAssemblerSerializer((entityOrDto as object).constructor as Class<unknown>);
+      if (serializer) {
+        return serializer(entityOrDto);
+      }
     }
     // eslint-disable-next-line @typescript-eslint/ban-types
     return (entityOrDto as unknown) as object;
diff --git a/packages/core/src/common/reflect.utils.ts b/packages/core/src/common/reflect.utils.ts
index 822a87dcf..9ed63649e 100644
--- a/packages/core/src/common/reflect.utils.ts
+++ b/packages/core/src/common/reflect.utils.ts
@@ -82,8 +82,22 @@ export class MapReflector<K = string> extends Reflector {
     this.defineMetadata(metadata, DTOClass);
   }
 
-  get<DTO, Data>(DTOClass: Class<DTO>, key: K, includeParents = false): MetaValue<Data> {
-    return this.getMetadata<Map<K, Data>>(DTOClass, includeParents)?.get(key);
+  get<DTO, Data>(DTOClass: Class<DTO>, includeParents?: boolean): MetaValue<Map<K, Data>>;
+  get<DTO, Data>(DTOClass: Class<DTO>, key: K, includeParents?: boolean): MetaValue<Data>;
+  get<DTO, Data>(
+    DTOClass: Class<DTO>,
+    key: K | boolean | undefined,
+    includeParents?: boolean,
+  ): MetaValue<Data | Map<K, Data>> {
+    if (typeof key === 'boolean' || typeof key === 'undefined') {
+      return this.getMetadata<Map<K, Data>>(DTOClass, includeParents ?? false);
+    }
+    return this.getMetadata<Map<K, Data>>(DTOClass, includeParents ?? false)?.get(key);
+  }
+
+  getValues<DTO, Data>(DTOClass: Class<DTO>, includeParents = false): MetaValue<Data[]> {
+    const values = this.getMetadata<Map<K, Data>>(DTOClass, includeParents)?.values();
+    return values ? [...values] : undefined;
   }
 
   has<DTO>(DTOClass: Class<DTO>, key: K): boolean {