Plusieurs convertisseurs de classe @Type de la même classe pour des sous-types de types différents

Question

Suivez-moi, cela peut devenir un peu déroutant :

• J'utilise NestJs et un validateur/transformateur de classe.
• Il existe un tableau qui peut contenir deux types.
• J'utilise @Type pour définir des éléments via des discriminateurs.
• J'utilise Transform car il est requis dans la sérialisation, sinon un objet vide sera créé.

Maintenant, le problème est que mon discriminateur est une énumération avec 7 valeurs, 6 d'entre elles pointent vers une classe et la dernière pointe vers un autre type. Le problème est que quel que soit le type d'énumération, lors de la sérialisation, il est toujours remplacé par le premier sous-type.

enum DiscrType = {A : "a", B : "b", C : "c"}

Discriminateur de classe {
 @IsEnum (TypeDiscr)
 tapez : Type de disque
}

la classe ClassONE étend le discriminateur {...}
la classe ClassTWO étend le discriminateur {...}

trucs de classe {
 @Type(() => Discriminateur, {
    discriminateur : {
      Type de propriété',
      sous-types : [
        { valeur : ClasseDEUX, nom : DiscrType.C},
        { value : ClassONE, name : DiscrType.A}, // se transforme toujours en cette valeur même si elle était B
        { valeur : ClassONE, nom : DiscrType.B},
   
      ],
    },
    keepDiscriminatorProperty : vrai,
  })
 @Transformer(
    ({ valeur }) =>
      value?.map((objet : ClassONE | ClassTWO ) =>
        objet.type === DiscrType.C
          ? plainToClass(classDEUX, objet)
          : plainToClass(ClassONE, objet),
      ),
  )
  @ValidateNested({chacun : vrai})
  propriété : (ClassONE | ClassTWO)[]
}

≪/pré>
Comportement :
new Stuff({type: DiscrType.B,...}) // Sérialisation avec Class Serializer

// Attendu:
x = {type : "b",...}
// Réel:
x = {type : "a",...} 

Answer 1

Pour l'instant, je ne sais pas si c'est la solution parfaite, mais dans mon projet, après avoir remplacé @Type par ceci, tous les tests sont toujours en cours d'exécution.

@Type((value) =>
    value.object.type === DiscrType.C? ClassTWO: ClassONE,
  )

Puisque cette méthode fonctionne, je la laisserai comme solution, mais veuillez mentionner si vous savez pourquoi vous devriez utiliser le discriminateur au lieu de cette solution, quels en sont les avantages ?