Add to Chrome
Add to Edge
Add to Firefox
Add to Opera
Add to Brave
Add to SafariWhen comparing TypeORM vs MikroORM, the Slant community recommends MikroORM for most people. In the question“What are the best JavaScript ORMs?” MikroORM is ranked 3rd while TypeORM is ranked 4th. The most important reason people chose MikroORM is:
MikroORM allows handling transactions automatically. When you call em.flush(), all computed changes are wrapped inside a database transaction.
Question Ranking
Pros
Pro Written in TypeScript
Integrates very well with Angular projects and other projects leveraging TypeScript.
Pro Abstracts SQL and NoSQL
Able to connect to SQL and NoSQL sources with a unified API.
Pro No major contenders
May inexplicably have no major contenders in TS land.
Pro Weak Controller Generation and Discovery
Loopback and Sails implement API generation natively, with lots of features. TypeORM integrates Express route / endpoint / controller generation via an extension.
Loopback implements complex database discovery with SQL and NoSQL stores. TypeORM can also generate models based on an existing database, but it is done via extension and the database must be SQL: Microsoft SQL Server, PostgreSQL, MySQL, or MariaDB.
Still, these are great features most Node ORMs today do not have at all.
Pro Implicit Transactions
MikroORM allows handling transactions automatically. When you call em.flush(), all computed changes are wrapped inside a database transaction.
Pro Powered by Unit of Work and Identity Map
Manages in memory state of loaded entities for you.
Pro DRY Entities
Uses source code analysis so you do not have to repeat yourself when defining entities. Simply define correct TypeScript types and you are good to go!
Pro Allows multiple ways to define entities
You can use decorators or define your schema via EntitySchema helper. You can also define custom MetadataProvider to customize how the discovery works.
Pro Easy-to-use and convinient way to use it
The first easy-to-use and convinient ORM in Typescript for Node.js
Pro SQL layer built on top of Knex
Allows to use knex directly (as well as native SQL) and map results to entities easily.
Pro Supports both SQL and NoSQL
Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite databases, and more can be supported via custom drivers right now.
Pro EntityGenerator
Allow to generate entities from existing database schema to get you up in speed.
Cons
Con Based on decorators
TypeORM relies on decorators, and obsolete implementations of them at that. To add insult to injury, simple decorator syntax is not provided. So you need to write e.g. @Column() instead of @Column. This is an issue with the API design, a very nasty one (Angular does it is not a good reason to do anything).
Con Uncertain future
Confusing/obscure/unpredictable/broken parts. Sometimes glorious, sometimes goofy. Devs almost abandoned the project. Feels like driving a luxury car with flat tires.
Con The first stable 1.0.0 version release was planned for autumn of 2018, today on 2020/03, they have an unstable 0.2.24 version
Still no 1.x release as of August 2023...
Con Poor documentation
Lacking a simple, hosted API reference
Con Obnoxious syntax
@Column()
public foo: string | null;
Should just do the right thing (a nullable column that has correct type annotation on the field). Instead this has to be:
@Column({ type: "string", nullable: true })
public code?: string | null;
Con In transactions when it throws an error, it doesn't roll back all operations within transactions
Con In transactions, many inserts generate an error
Con Confuses Classes with Types
The conflation of types and classes is a bad thing for JavaScript and TypeScript. To make matters worse, they often lead to the maximally complicated solution, especially for simple problems, result in awkward interop, and are incompatible with the extensive syntactic sugar that JavaScript provides for objects.
