TypeORM incorrectly tries to save embedded entities first

If you are working with TypeScript and using TypeORM, you may come across a situation where TypeORM incorrectly tries to save embedded entities first. This can lead to unexpected behavior and errors in your application. In this blog post, we will explore the issue and provide multiple solutions to resolve it.

The Problem

When using TypeORM, you may define embedded entities within your main entity. An embedded entity is an entity that is saved within the same table as the main entity. However, TypeORM sometimes tries to save the embedded entities first, which can cause issues if the main entity depends on the embedded entities.

Solution 1: Using cascades

One solution to this problem is to use cascades in your entity definition. Cascades allow you to define how TypeORM should handle the saving and deletion of related entities.

To resolve the issue, you can add the { cascade: true } option to the embedded entity property in your main entity definition. This tells TypeORM to automatically save the embedded entities when saving the main entity.


@Entity()
class MainEntity {
  // ...

  @Embedded(() => EmbeddedEntity, { cascade: true })
  embeddedEntity: EmbeddedEntity;

  // ...
}

Solution 2: Saving entities separately

If using cascades is not suitable for your use case, you can manually save the entities separately. This allows you to control the order in which the entities are saved.

In your code, you can first save the embedded entities and then save the main entity. This ensures that the embedded entities are saved before the main entity is saved.


const embeddedEntity = new EmbeddedEntity();
// set properties of embeddedEntity

await connection.manager.save(embeddedEntity);

const mainEntity = new MainEntity();
mainEntity.embeddedEntity = embeddedEntity;
// set properties of mainEntity

await connection.manager.save(mainEntity);

Conclusion

TypeORM incorrectly trying to save embedded entities first can be a frustrating issue to deal with. However, by using cascades or saving entities separately, you can overcome this problem and ensure the correct order of saving entities.

Remember to choose the solution that best fits your use case and consider the dependencies between your entities. By implementing the appropriate solution, you can avoid unexpected behavior and errors in your TypeScript application.

TypeORM incorrectly tries to save embedded entities first