[Feature] Polymorphic embedded entities

[dvlalex]

Is your feature request related to a problem? Please describe.
I bumped into this earlier after upgrading to v4. I think it would be useful(I'm on mongo, so I use embedded properties a lot) to have embedded properties work the same as STI entities, where B & C inherits A, and D holds a property that can be either B or C. This is in a way related to #706, but it should be easier to achieve since there's no FKs to handle here.

Say we have:

enum AnimalType {
	CAT,
	DOG,
}

abstract class Animal {
	@Enum(() => AnimalType)
	type: AnimalType;
	
	@Property({ type: String })
	name: string;
}

@Embeddable()
class Cat extends Animal {
	@Property({ type: Boolean })
	canMeow = true;

	constructor(name: string) {
		this.type = AnimalType.CAT;
		this.name = name;
	}
}

@Embeddable()
class Dog extends Animal {
	@Property({ type: Boolean })
	canBark = true;
	
	constructor(name: string) {
		this.type = AnimalType.DOG;
		this.name = name;
	}
}

I would expect to be able to do:

@Entity()
class Profile {
	@Embedded()
	pet: Dog | Cat;
}

Describe the solution you'd like
I think we can make Embeddables take on some parameters that would reference the type and have the entity mapper look for it if provided. Same as STI works now for entity types. As for the Embedded decorator, I would have this receive an array of entities that can be mapped against instead of a single entity.

Describe alternatives you've considered
The way i achieved this is by having a custom type and doing my own mapping based on the type property of the "animal" in the example above. The issue with this though, is that custom types aren't diffed when changes are being made to the parent entity which is normal, but I have to look for the changes myself which beats the purpose.

[B4nan]

Looking into this now. We will need more information in the metadata, similarly to STI, but I feel like I found a way to incorporate this into the codebase without too much rewriting - similarly to pivot tables, we can have virtual entities for such polymorphic entities (one for the whole tuple of possible entities, so here for both Cat and Dog). This way we can still internally refer to a single target metadata for such properties. This virtual poly entity would have references to all possible classes, as well as merged property map (will be needed mainly for SQL drivers and inline mode).

I can imagine something like this:

enum AnimalType {
  CAT,
  DOG,
}

@Embeddable({ abstract: true, discriminatorColumn: 'type' })
abstract class Animal {

  @Enum(() => AnimalType)
  type!: AnimalType;

  @Property({ type: String })
  name!: string;

}

@Embeddable({ discriminatorValue: AnimalType.CAT })
class Cat extends Animal {

  @Property({ type: Boolean, nullable: true })
  canMeow = true;

  constructor(name: string) {
    super();
    this.type = AnimalType.CAT;
    this.name = name;
  }

}

@Embeddable({ discriminatorValue: AnimalType.DOG })
class Dog extends Animal {

  @Property({ type: Boolean, nullable: true })
  canBark = true;

  constructor(name: string) {
    super();
    this.type = AnimalType.DOG;
    this.name = name;
  }

}

@Entity()
class Owner {

  @PrimaryKey()
  id!: number;

  @Property()
  name!: string;

  // we could probably infer this via ts-morph, but let's not overcomplicate things for now
  @Embedded(() => [Cat, Dog])
  pet!: Cat | Dog;

}