Getting issue with extends class when upgraded TypeORM from 0.2.20 to 0.3.20? Here’s the Solution!

Upgrading TypeORM from 0.2.20 to 0.3.20 can be a thrilling experience, but it can also bring some unexpected issues, especially when working with extended classes. In this article, we’ll dive into the common problems that arise when using extended classes with TypeORM 0.3.20 and provide you with step-by-step solutions to get you back on track.

The Issue: Unable to Extend Classes with TypeORM 0.3.20

When upgrading to TypeORM 0.3.20, you might encounter issues with extended classes, particularly when using the `extends` keyword. The error message might look something like this:

Error: Cannot extend entities with different metadata.

This error occurs because TypeORM 0.3.20 introduced significant changes to the metadata handling mechanism, which affects how entities are extended. In this section, we’ll explore the reasons behind this issue and provide a solution.

Understanding the Changes in TypeORM 0.3.20

In TypeORM 0.2.20, the `metadata` property was a simple object that contained entity metadata. However, in TypeORM 0.3.20, the `metadata` property has been replaced with a more complex `EntityMetadata` class. This change affects how entities are extended and how metadata is handled.

Here’s a comparison of the `metadata` property in TypeORM 0.2.20 and 0.3.20:

TypeORM Version	metadata Property
TypeORM 0.2.20	Simple object containing entity metadata
TypeORM 0.3.20	EntityMetadata class instance containing entity metadata

Solution 1: Update Your Entity Extensions

To resolve the issue, you’ll need to update your entity extensions to work with the new `EntityMetadata` class. Here’s an example of how you can update your code:

// Before (TypeORM 0.2.20)
@ Entity()
export class BaseUser {
  @ Column()
  id: number;

  @ Column()
  name: string;
}

@ Entity()
export class ExtendedUser extends BaseUser {
  @ Column()
  address: string;
}

// After (TypeORM 0.3.20)
@ Entity()
export class BaseUser {
  @ Column()
  id: number;

  @ Column()
  name: string;
}

@ Entity()
export class ExtendedUser {
  @ Column()
  address: string;
}

export function extendBaseUser(BaseEntity: new () => T) {
  @ Entity()
  class ExtendedEntity extends BaseEntity {
    @ Column()
    address: string;
  }

  return ExtendedEntity;
}

const ExtendedUser = extendBaseUser(BaseUser);

In this example, we’ve replaced the extended class with a function that returns a new entity class. This approach allows you to decouple the extended entity from the base entity and avoid conflicts with the `EntityMetadata` class.

Solution 2: Use the `@Inheritance` Decorator

Another solution is to use the `@Inheritance` decorator provided by TypeORM. This decorator allows you to specify the inheritance strategy for your entities. Here’s an example:

@ Entity()
@ Inheritance('SINGLE_TABLE')
export class BaseUser {
  @ Column()
  id: number;

  @ Column()
  name: string;
}

@ Entity()
@ Inheritance('SINGLE_TABLE')
export class ExtendedUser extends BaseUser {
  @ Column()
  address: string;
}

In this example, we’ve added the `@Inheritance` decorator to both the base and extended entities. This decorator specifies the inheritance strategy as `SINGLE_TABLE`, which tells TypeORM to use a single table for both entities.

Understanding the `@Inheritance` Decorator

The `@Inheritance` decorator is a powerful tool that allows you to control the inheritance strategy for your entities. Here are the available inheritance strategies:

• `SINGLE_TABLE`: This strategy uses a single table for all entities in the inheritance hierarchy.
• `TABLE_PER_CLASS`: This strategy uses a separate table for each entity in the inheritance hierarchy.
• `JOINED_TABLE`: This strategy uses a separate table for each entity in the inheritance hierarchy, but also creates a join table to map the relationships between entities.

By default, TypeORM uses the `SINGLE_TABLE` strategy for inheritance. However, you can override this default by using the `@Inheritance` decorator.

Best Practices for Entity Inheritance with TypeORM 0.3.20

To avoid common issues with entity inheritance, follow these best practices:

1. Use the `@Inheritance` decorator: Specify the inheritance strategy for your entities using the `@Inheritance` decorator.
2. Avoid mixing metadata: Keep your metadata consistent across all entities in the inheritance hierarchy.
3. Use separate tables for each entity: Consider using the `TABLE_PER_CLASS` inheritance strategy to avoid conflicts between entities.
4. Test your entities thoroughly: Verify that your entities are working as expected after upgrading to TypeORM 0.3.20.

By following these best practices, you can ensure that your entity inheritance works smoothly with TypeORM 0.3.20.

Conclusion

Upgrading to TypeORM 0.3.20 can be a challenging task, especially when working with extended classes. However, by understanding the changes in TypeORM 0.3.20 and following the solutions outlined in this article, you can overcome the common issues that arise when using extends class with TypeORM 0.3.20. Remember to update your entity extensions, use the `@Inheritance` decorator, and follow best practices for entity inheritance to ensure a smooth transition to TypeORM 0.3.20.

If you’re still experiencing issues or have further questions, feel free to ask in the comments section below. Happy coding!

Frequently Asked Question

Getting issues with extends class when upgraded TypeORM from 0.2.20 to 0.3.20? We’ve got you covered! Check out our FAQs below to find the solution.