TypeORM-இன் நன்மைகள் மற்றும் தீமைகள் என்ன?

Question

IT Interview Practice · Accepted Answer

**TypeORM** என்பது Node.js-க்கான TypeScript-first ORM ஆகும். இது classes-ஐ tables-க்கு map செய்ய decorators-ஐ நம்பியிருக்கிறது மற்றும் **Active Record** மற்றும் **Data Mapper** ஆகிய இரண்டு patterns-ஐயும் ஆதரிக்கிறது. அதன் மிகப்பெரிய கவர்ச்சி ஆழமான TypeScript ஒருங்கிணைப்பு; அதன் மிகப்பெரிய அபாயங்கள் query-layer-இன் கரடுமுரடான ஓரங்களும் சீரற்ற பராமரிப்பு வரலாறும்.

## நன்மைகள்

- **TypeScript-native.** Entities என்பவை decorated classes, எனவே models, relations, மற்றும் (கவனத்துடன்) queries முதல் முடிவு வரை typed ஆக இருக்கும்.
- **இரண்டு patterns.** சிறிய apps-க்கு Active Record (`user.save()`), அல்லது testable, decoupled code-க்கு Data Mapper (`repository.save(user)`) பயன்படுத்தவும்.
- **Decorator-driven schema.** Columns, relations, indexes, மற்றும் cascades entity-இல் inline ஆக அறிவிக்கப்படுகின்றன.

```ts
@Entity()
class User {
  @PrimaryGeneratedColumn() id: number;
  @Column({ unique: true }) email: string;
  @OneToMany(() => Post, (p) => p.author) posts: Post[];
}

const users = await dataSource
  .getRepository(User)
  .find({ where: { email: "a@b.com" }, relations: { posts: true } });
```

- schema பரிணாமத்திற்கான **Migrations & CLI**, மேலும் சிக்கலான SQL-க்கான ஒரு நெகிழ்வான **QueryBuilder**.
- Postgres, MySQL, SQLite, SQL Server மற்றும் பிறவற்றில் வேலை செய்கிறது.

## தீமைகள்

- **query ஓரத்தில் type-safety கசிகிறது.** `find` options மற்றும் QueryBuilder பகுதியளவே typed; தவறான column பெயர் பெரும்பாலும் compile நேரத்தில் அல்ல, runtime-இல் தோல்வியடைகிறது.
- **சிக்கலான queries சங்கடமாகின்றன.** ஆழமான joins, subqueries, மற்றும் aggregation பெரும்பாலும் உங்களை raw SQL-க்குத் திரும்பத் தள்ளுகின்றன.
- **பராமரிப்பு & நிலைத்தன்மை.** இந்த project-க்கு மெதுவான காலகட்டங்களும் versions-க்கு இடையே breaking changes-ம் இருந்துள்ளன; சில bugs நீடிக்கின்றன.
- **Migration உராய்வு.** தானாக உருவாக்கப்படும் migrations இரைச்சலாக இருக்கலாம், கை-திருத்தம் தேவைப்படலாம்.
- **Lazy relations & செயல்திறன் ஆபத்துகள்** — relations வேண்டுமென்றே load செய்யப்படாவிட்டால் N+1 queries-ஐத் தூண்டுவது எளிது.

## எப்போது பொருந்தும்

புதிய TypeScript backends (இது **NestJS** உடன் இயற்கையாக இணைகிறது), decorator-based models-ஐ மதிக்கும் மற்றும் typed entities விரும்பும் teams, மற்றும் queries பெரும்பாலும் CRUD ஆக இருந்து அவ்வப்போது QueryBuilder பயன்படுத்தும் apps.

## இது ஏன் முக்கியம்

ஒரு ORM-ஐத் தேர்ந்தெடுப்பது ஒவ்வொரு feature-ம் database-ஐ எப்படித் தொடுகிறது என்பதை வடிவமைக்கும் நீண்டகால உறுதிமொழி. TypeORM-இன் TypeScript-first வடிவமைப்பு typed codebases-க்கு உண்மையான உற்பத்தித்திறன் வெற்றி, ஆனால் நேர்காணல் செய்பவர்கள் அதன் வரம்புகளையும் நீங்கள் அறிவீர்கள் என்று கேட்க விரும்புகிறார்கள் — பகுதி query typing, சிக்கலான-query வலி, மற்றும் அதிர்ச்சியான release வரலாறு — இதனால் hype-இன் மீது ஏற்றுக்கொள்வதற்குப் பதிலாக அதன் ergonomics அதன் கரடுமுரடான ஓரங்களை மிஞ்சும் நேரத்தை நீங்கள் தீர்மானிக்க முடியும்.

நன்மைகள்

தீமைகள்

எப்போது பொருந்தும்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்