Evaluating 4 well-liked NestJS ORMs

NestJS is a well-liked Node.js server-side framework. It’s extremely customizable, comes with a wealthy ecosystem, and is suitable with most Node.js libraries, together with the ORM libraries.

ORMs in NestJS

Object-relational mapping (ORM) is a method that abstracts your database tables to knowledge objects in reminiscence. It lets you question and write knowledge to databases utilizing knowledge objects. ORMs are used to make database entry simpler, as builders received’t want to write down uncooked queries.

ORMs have their limitations, reminiscent of efficiency points with advanced queries, however they’ll nonetheless make your life simpler when utilized in the suitable locations.

NestJS is database-agnostic. For comfort, NestJS offers tight integrations with TypeORM and Sequelize out of the field with the @nestjs/typeorm and @nestjs/sequelize packages. You may also instantly use any common goal Node.js database integration library or ORM, however the ecosystem of NestJS ORMs is so huge, it may be daunting to decide on the suitable one to your undertaking.

On this article, we’re going to stroll by utilizing 4 frequent ORMs with NestJS. They’re:

Our intention is to summarize their frequent traits, like recognition, options, documentation, and maturity, and for every ORM, a code snippet shall be supplied to provide the easiest instance of making use of the framework.

NestJS and Sequelize

Launched round 2014, Sequelize is an easy-to-use and Promise-based ORM for Node.js.

It helps many databases, together with PostgreSQL, MySQL, MariaDB, SQLite, DB2 and MSSQL. Its limitations embrace an absence of NoSQL assist and solely supporting the Lively File sample.

Options

Sequelize offers a wealthy set of options: transaction and migration assist, mannequin validations, keen and lazy loading, and browse replication, amongst others. Sequelize has cheap documentation with wealthy info and good examples, however generally I discover it’s not straightforward to seek for a specific matter.

Sequelize comes with a CLI that may create a database, initialize configuration and seeders, or handle migration. It additionally makes use of the Lively File sample. Within the Lively File sample, a database row is mapped into an object in software, and a database desk is represented by a category. Thus, once we create an entity object and name the save technique, a brand new row is added to the database desk.

The principle advantage of the Lively File sample is its simplicity: you’ll be able to instantly use the entity lessons to characterize and work together with the database tables.

Setup

Sequelize is straightforward to arrange and use. Under is an instance of the fundamental database configuration and operation.

// Firstly, we create a Sequelize occasion with an choices object
export const databaseProviders = [
  {
    provide: 'SEQUELIZE',
    useFactory: async () => {
      const sequelize = new Sequelize({
        dialect: 'postgres',
        host: 'localhost',
        port: 5432,
        username: 'postgres',
        password: 'postgres',
        database: 'postgres',
      });
      sequelize.addModels([Cat]); // Add all fashions
      await sequelize.sync(); // Sync database tables
      return sequelize;
    },
  },
];

// Then, export the supplier to make it accessible
@Module({
  suppliers: [...databaseProviders],
  exports: [...databaseProviders],
})
export class DatabaseModule {}

// Outline mannequin entity, every characterize a desk within the database
@Desk
export class Cat extends Mannequin {
  @Column
  title: string;

  @Column
  age: quantity;

  @Column
  breed: string;
}
// Create a repository supplier
export const catsProviders = [
  {
    provide: 'CATS_REPOSITORY',
    useValue: Cat,
  },
];
// In CatsService, we inject the repository
export class CatsService {
  constructor(
    @Inject('CATS_REPOSITORY')
    non-public catsRepository: typeof Cat,
  ) {}

// Then, we are able to carry out database operations
this.catsRepository.findAll<Cat>();

In some instances, the place it’s simply simpler to execute uncooked SQL queries, you need to use the perform sequelize.question.

// SQL Script. Supply https://sequelize.org/docs/v6/core-concepts/raw-queries/
const [results, metadata] = await sequelize.question("UPDATE customers SET y = 42 WHERE x = 12");
// Outcomes shall be an empty array and metadata will comprise the variety of affected rows.

Sequelize is tough at work making official TypeScript assist doable, however for now, it’s nonetheless really helpful that you just use the sequelize-typescript package deal to work with TypeScript in your undertaking.

Group and recognition

Sequelize is a really mature and steady ORM. It has an energetic group and a big selection of crucial tooling. As one of the vital well-liked ORM frameworks, Sequelize has 26K stars and 4K forks on GitHub. It’s additionally instantly supported by NestJS with @nestjs/sequelize.

Use instances

Sequelize is a common goal ORM for Node.js apps. If you’re on the lookout for a steady, easy-to-use ORM, it’s value your consideration.

NestJS and TypeORM

TypeORM is one other mature ORM for Node.js. It has a wealthy function set, together with an entity supervisor, connection pooling, replication, and question caching. It’s additionally instantly supported by NestJS with its personal package deal, @nestjs/typeorm.

Launched in 2016, TypeORM helps the dialects PostgreSQL, MySQL, MariaDB, SQLite, MSSQL, and MongoDB. That signifies that you need to use each NoSQL and SQL databases on the similar time with TypeORM.

Options

TypeORM offers a CLI that may create entities, tasks, and subscribers or handle migration. It helps each Lively File and Knowledge Mapper patterns.

The Knowledge Mapper sample provides an information entry layer (DAL) between the enterprise area of your software and the database. Utilizing the Knowledge Mapper sample offers extra flexibility and higher efficiency, because it makes extra environment friendly use of the database than a naive Lively File implementation. Offering each approaches provides you a selection of sample that fits your software.

Very like some open supply tasks, its documentation has room for enchancment. One of many frequent points is an absence of crucial API particulars.

Setup

Under is the fundamental database configuration and operation for TypeORM utilizing the Lively File sample.

// Firstly, we setup Database Connection
@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'postgres',
      password: 'postgres',
      database: 'postgres',
      entities: [Cat],
      synchronize: true, // Sync the entities with the database each time the applying runs
    }),
    CatsModule,
  ],
})

// Then you'll be able to outline the information entity
@Entity()
export class Cat {
  @PrimaryGeneratedColumn()
  id: quantity;

  @Column()
  title: string;

  @Column()
  breed: string;
}
// We will use the repository design sample which implies every entity has its personal repository.
// Right here, we inject the catRepository into your service
export class CatsService {
  constructor(
    @InjectRepository(Cat)
    non-public catsRepository: Repository<Cat>,
  ) {}
  
// Then you need to use the injected repo to carry out database operation
  this.catsRepository.discover();
  this.catsRepository.save<Cat>(cat);

To run a uncooked SQL question, you need to use the @InjectConnection decorator and use the question technique to run a customized question script.

// Inject the connection
constructor(@InjectConnection() non-public readonly connection: Connection) 
{} 
// Run the question
this.connection.question('SELECT * FROM [TableName];');

You should use both JavaScript or TypeScript with TypeORM. Utilizing TypeORM with TypeScript is extra pure as in comparison with different ORMs, because it’s written by TypeScript.

Group and recognition

It’s one of the vital well-liked ORM libraries, with 28.2K stars and 5.1K forks on GitHub.

With its wealthy function set and adaptability, TypeORM is among the finest ORMs for NestJS.

Use instances

TypeORM can run on Node.js and numerous different platforms. It’s a nice selection in case your software requires a number of of the next options:

• Scalable to a big, enterprise-grade app
• Assist for a number of databases
• Assist for each SQL and NoSQL databases
• Assist for a number of platforms, together with Node.js, Ionic, Cordova, React Native, NativeScript, Expo, or Electron

NestJS and MikroORM

MikroORM is one other TypeScript ORM for Node.js primarily based on the Knowledge Mapper, Unit of Work, and Identification Map patterns.

Launched in 2018, it’s a comparatively younger ORM. MikroORM helps each SQL and NoSQL databases, together with MongoDB, MySQL, PostgreSQL and SQLite databases. MikroORM additionally has its personal NestJS assist, @mikro-orm/nestjs package deal, which is a third-party package deal and never managed by the NestJS workforce.

Options

MikroORM offers a formidable checklist of options, together with transactions, assist for the Identification Map sample, cascading persist and take away, a question builder, and extra. It’s a fully-featured ORM with all the most important database choices, and is definitely migrated to from TypeORM, should you’re trying to swap.

It comes with a CLI instrument that may create/replace/drop database schema, handle database migration, and generate entities.

MikroORM helps the Knowledge Mapper sample. It’s additionally constructed primarily based on Unit of Work and Identification Map patterns. Implementing Unit of Work permits us to deal with transactions robotically. It’s additionally optimized for transactions through Identification Map patterns, which makes it doable to stop pointless round-trips to the database. These patterns additionally assist MikroORM obtain good efficiency: a current benchmark reveals it solely takes round 70ms for inserting 10K entities with SQLite.

Setup

The syntax of MikroORM could be very easy and easy. Under is an instance of utilizing MikroORM for the best database operations in NestJS.

// Firstly, import MikroOrmModule in App.module
@Module({
  imports: [MikroOrmModule.forRoot(), CatsModule],
})
// The Database configuration is retailer in mikro-orm.config.ts
const config: Choices = {
  entities: [Cat],
  dbName: 'postgres',
  sort: 'postgresql',
  port: 5432,
  host: 'localhost',
  debug: true,
  consumer: 'postgres',
  password: 'postgres',
} as Choices;

// The config paths are outlined in package deal.json
  "mikro-orm": {
    "useTsNode": true,
    "configPaths": [
      "./src/mikro-orm.config.ts",
      "./dist/mikro-orm.config.js"
    ]
  }
// To make use of repository sample, we register entities through forFeature() in function module
@Module({
  imports: [MikroOrmModule.forFeature({ entities: [Cat] })],
})
export class CatsModule {}

// We inject the repository into service
  constructor(
    @InjectRepository(Cat)
    non-public readonly catRepository: EntityRepository<Cat>,
  ) {}

 // Then, we are able to carry out database operation
this.catRepository.findOne(findOneOptions);

Group and recognition

The documentation of MikroORM is actively maintained and simple to navigate. Though it’s one of many youngest ORMs, it doesn’t have a protracted checklist of open points in GitHub. The repo is actively maintained, and points are usually resolved shortly.

MikroORM is constructed to beat some present problems with different Node.js ORMs, like lack of transaction assist. It’s quick rising and presents robust sort security along with an inventory of nice options.

Use instances

MikroORM stands out due to its distinctive options, robust typing and good assist. It’s value contemplating if you’re on the lookout for an ORM for:

• A greenfield app that wants good transaction assist
• An app that wants common batch knowledge updates and quick efficiency

NestJS and Prisma

Prisma is an open supply ORM for Node.js. It at present helps PostgreSQL, MySQL, SQL Server, SQLite, MongoDB, and CockroachDB (which continues to be obtainable for preview solely).

Prisma integrates easily with NestJS. Not like the opposite ORMs, there isn’t a must have a separate package deal for the NestJS-ORM integration. As an alternative, the Prisma CLI package deal is the one factor we have to use Prisma in NestJS.

Options

Prisma is a singular library in contrast with different ORMs mentioned on this article. As an alternative of utilizing entity fashions as different ORMs do, it makes use of a schema definition language. Builders can outline the information fashions with Prisma schema, and the fashions are used to generate the migration information for the chosen database. It additionally generates strongly typed code to work together with the database.

Schema information are used as a single supply of reality for each database and software, and the code technology primarily based on it helps to construct type-safe queries to catch errors throughout compile time.

Prisma offers good tooling, together with Prisma CLI and Prisma Studio. You should use the CLI to create migrations, or use the Studio to examine databases, which works effectively with the Entity construction of Prisma. It additionally offers a Prisma knowledge platform for database internet hosting.

The documentation of Prisma is properly formatted and actively maintained.

Setup

Utilizing Prisma, builders can merely outline their schemas and never fear about particular ORM frameworks. Under is essentially the most fundamental utilization of PrismaORM with NestJS.

// Firstly, we want a schema file to mannequin the database
generator consumer {
  supplier = "prisma-client-js"
}

datasource db {
  supplier = "postgresql"
  url      = env("DATABASE_URL") // the DATABASE_URL is saved in .env file
}

mannequin Cat {
  id            Int         @default(autoincrement()) @id
  title          String
  age           Int
  breed         String   
}

// To generates SQL information and in addition runs them on the configured database, run following command
 npx prisma migrate dev --name init

// Create a Database service to work together with the Prisma Shopper API
@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
  async onModuleInit() {
    await this.$join();
  }

  async enableShutdownHooks(app: INestApplication) {
    this.$on('beforeExit', async () => {
      await app.shut();
    });
  }
}
// In service layer, we inject the DatabaseService
constructor(non-public prisma: PrismaService) {}

// We will carry out database operation through Prisma consumer api as beneath
// Please notice that we use Prisma Shopper's generated sorts, just like the "Cat"
  async cat(
    catWhereUniqueInput: Prisma.CatWhereUniqueInput,
  ): Promise<Cat | null> {
    return this.prisma.cat.findUnique({
      the place: catWhereUniqueInput,
    });
  }

Group and recognition

First launched in 2019, Prisma is the latest ORM of the 4 we mentioned. It is going to want time to get to a extra mature state. Lately, the discharge of model 3 launched just a few breaking modifications. There are additionally some present points famous in GitHub, reminiscent of that it doesn’t assist some Postgres column sorts.

With 23.3K GitHub stars and 828 forks, it’s grown quickly in recognition.

Use instances

General, Prisma is a really promising ORM. It’s designed to mitigate present issues in conventional ORMs and can be utilized with both JavaScript or TypeScript. The benefit of utilizing TypeScript is which you can leverage the Prisma Shopper’s generated sorts for higher type-safety.

Some good use instances for Prisma are:

• Speedy prototype growth for brand new apps
• Apps that require good database tooling and robust typing assist

Abstract

There are a selection of ORMs that can be utilized along with NestJS. Thus, selecting an appropriate ORM to your NestJS software could be a arduous resolution. On this article, we’ve got walked by 4 well-liked ORMs, and mentioned their strengths and weaknesses.

I additionally created a repo with essentially the most fundamental pattern code for every ORM, so will probably be simpler so that you can have a direct impression when you have not used them. Yow will discover the supply code right here.