Top 10 Killer Features of MikroORM to Utilize in Your Ton Tarot Project

MikroORM is a TypeScript ORM that provides a powerful and flexible way to interact with your database in NestJS applications. It offers a rich set of features that can significantly enhance your development experience and application performance. Below are the top 10 cool features of MikroORM that you should try in your Ton Tarot project.

1. TypeScript Decorators for Entity Definitions

What it is:

• Define your database entities using TypeScript classes and decorators.
• Use decorators like @Entity(), @Property(), @PrimaryKey(), etc.

Why it's cool:

• Seamless Integration with NestJS: Decorators align well with NestJS's programming model.
• Type Safety: Full TypeScript support ensures type safety throughout your application.
• Readable and Maintainable Code: Entity definitions are clear and concise.

How to use it:

@Entity()
export class User {
  @PrimaryKey()
  id!: number;

  @Property()
  name!: string;

  @Property()
  email!: string;
}

---

2. Identity Map and Unit of Work Pattern

What it is:

• Identity Map: Ensures that each entity is only loaded once per request.
• Unit of Work: Automatically tracks changes to entities and persists them in a single transaction.

Why it's cool:

• Efficiency: Prevents duplicate queries and reduces database load.
• Automatic Change Tracking: No need to manually track changes to entities.
• Consistency: Ensures data consistency within a transaction.

How to use it:

• Changes to entities are automatically tracked.
• Call em.flush() to persist changes.

const user = await em.findOne(User, { id: 1 });
user.name = 'New Name';
await em.flush(); // Changes are persisted here

---

3. Powerful Query Builder

What it is:

• A fluent API for building complex database queries.

Why it's cool:

• Flexibility: Build advanced queries without writing raw SQL.
• Type Safety: Query builder methods are type-safe.
• Complex Queries Made Easy: Supports joins, subqueries, aggregations, and more.

How to use it:

const users = await em
  .createQueryBuilder(User)
  .select('*')
  .where({ isActive: true })
  .orderBy({ createdAt: QueryOrder.DESC })
  .limit(10)
  .getResultList();

---

4. Eager and Lazy Loading Relations

What it is:

• Control how related entities are loaded (eagerly or lazily).

Why it's cool:

• Performance Optimization: Fetch only what you need when you need it.
• Flexibility: Configure default fetch strategies or override them per query.

How to use it:

• Eager Loading:

@Entity()
export class Post {
  @OneToMany(() => Comment, (comment) => comment.post, { eager: true })
  comments = new Collection<Comment>(this);
}

• Lazy Loading:

@Entity()
export class Post {
  @OneToMany(() => Comment, (comment) => comment.post)
  comments = new Collection<Comment>(this);
}

// Access comments when needed
const post = await em.findOne(Post, { id: 1 });
await post.comments.init(); // Loads comments

---

5. Built-in Migrations System

What it is:

• Generate and run database migrations directly from your entity definitions.

Why it's cool:

• Schema Management: Keep your database schema in sync with your code.
• Version Control: Migrations are stored as files and can be committed to your repository.
• Automated: Generate migrations automatically based on changes in entities.

How to use it:

• Generate migration:

npx mikro-orm migration:create

• Run migrations:

npx mikro-orm migration:up

---

6. Entity Manager and Repositories

What it is:

• Entity Manager (em): Central point for database operations.
• Repositories: Optional layer for entity-specific operations.

Why it's cool:

• Consistency: Use em to manage all entities uniformly.
• Customization: Create repositories for entities with custom methods.
• Testability: Easier to mock and test database operations.

How to use it:

• Using Entity Manager:

const user = await em.findOne(User, { email: 'test@example.com' });

• Using Repositories:

const userRepo = em.getRepository(User);
const user = await userRepo.findOne({ email: 'test@example.com' });

---

7. Transactions Support

What it is:

• Execute multiple database operations within a transaction context.

Why it's cool:

• Data Integrity: Ensure that a series of operations either all succeed or all fail.
• Easy to Use: Wrap your code within a transaction method.

How to use it:

await em.transactional(async (em) => {
  const user = new User();
  em.persist(user);

  const post = new Post();
  post.author = user;
  em.persist(post);
});

---

8. Embeddables (Component Entities)

What it is:

• Allow nesting entities within entities without creating separate tables.

Why it's cool:

• DRY Principle: Reuse common fields across entities.
• Simplify Schema: Reduce the number of tables.
• Type Safety: Embeddables are strongly typed.

How to use it:

@Embeddable()
class Address {
  @Property()
  street!: string;

  @Property()
  city!: string;
}

@Entity()
class User {
  @Embedded(() => Address)
  address!: Address;
}

---

9. Event Listeners and Subscribers

What it is:

• Hook into the lifecycle events of entities (e.g., onInit, beforeCreate, afterUpdate).

Why it's cool:

• Auditing: Automatically track changes, timestamps, or user actions.
• Validation and Transformation: Validate or modify data before persisting.

How to use it:

@Entity()
class User {
  @Property()
  createdAt: Date = new Date();

  @BeforeUpdate()
  updateTimestamp() {
    this.updatedAt = new Date();
  }
}

---

10. Soft Deletes and Filters

What it is:

• Implement soft delete functionality by marking records as deleted without physically removing them.
• Use filters to automatically exclude soft-deleted records from queries.

Why it's cool:

• Data Retention: Keep historical data for auditing or recovery.
• Transparency: Filters make it seamless; your queries behave as if the records are deleted.

How to use it:

• Define a deletedAt property:

@Entity()
class Post {
  @Property({ nullable: true })
  deletedAt?: Date;
}

• Enable filters:

em.addFilter('softDelete', { deletedAt: null }, { default: true });

• Soft delete a record:

post.deletedAt = new Date();
await em.flush();

---

Bonus Feature: Custom Naming Strategies

What it is:

• Customize how table names, column names, and relations are named in the database.

Why it's cool:

• Consistency with Existing Databases: Match naming conventions of an existing schema.
• Readability: Improve clarity of database schema.

How to use it:

// Define your custom naming strategy
class MyNamingStrategy extends UnderscoreNamingStrategy {
  /*...*/
}

// Configure it in MikroORM options
const orm = await MikroORM.init({
  namingStrategy: MyNamingStrategy,
  // other options...
});

---

Conclusion

By leveraging these powerful features of MikroORM, you can enhance your Ton Tarot project by writing cleaner code, improving performance, and ensuring data integrity. These features align well with NestJS and PostgreSQL, providing a robust foundation for your application's data layer.

Feel free to explore these features further and integrate them into your project to take full advantage of what MikroORM has to offer. If you need assistance with implementation or have questions about specific use cases, don't hesitate to ask!

---

id: micro_orm