Suivez-moi, cela peut devenir un peu déroutant :
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",...}
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.
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 ?