import { ValidationPipe } from '@nestjs/common'
import { AllExceptionFilter } from './exception-filter'
…
  app.useGlobalPipes(newValidationPipe())
  app.useGlobalFilters(newAllExceptionFilter(app.get(HttpAdapterHost)))

import { MikroORM } from '@mikro-orm/core'

Entities

Base Entity

All classes should have the same automatic basic functionalities:

1. an id of type uuid as primary key
2. a creation date in createdAt
3. date of last update in updatedAt

import { Entity, PrimaryKey, Property } from '@mikro-orm/core'
import { v4 } from 'uuid'

@Entity({ abstract: true })
export abstract class Base {

  @PrimaryKey()
  id: string = v4()

  @Property()
  createdAt: Date = new Date()

  @Property({ onUpdate: () => new Date() })
  updatedAt: Date = new Date()

}

Author

Define the author in src/author/entities/author.entity.ts:

import { Entity, Property } from '@mikro-orm/core'
import { Base } from '../../base/entities/base.entity'
import { CreateAuthorDto } from '../dto/create-author.dto'

@Entity()
export class Author extends Base {
  constructor(createAuthorDto: CreateAuthorDto) {
    super()
    Object.assign(this, createAuthorDto)
  }

  @Property()
  first_names?: string[]

  @Property()
  last_names!: string[]

  @Property()
  born?: Date

  @Property()
  died?: Date
}

Publisher

Define the publisher in src/publisher/entities/publisher.entity.ts:

import { Entity, Property } from '@mikro-orm/core'
import { Base } from '../../base/entities/base.entity'
import { CreatePublisherDto } from '../dto/create-publisher.dto'

@Entity()
export class Publisher extends Base {
  constructor(createPublisherDto: CreatePublisherDto) {
    super()
    Object.assign(this, createPublisherDto)
  }

  @Property()
  publisher_names?: string[]

  @Property()
  publisher_address_lines?: string[]

}

Book

Define the book in src/book/entities/book.entity.ts:

import { Entity, Property } from '@mikro-orm/core'
import { Author } from 'src/author/entities/author.entity'
import { Publisher } from 'src/publisher/entities/publisher.entity'
import { Base } from '../../base/entities/base.entity'
import { CreateBookDto } from '../dto/create-book.dto'

@Entity()
export class Book extends Base {
  constructor(createBookDto: CreateBookDto) {
    super()
    Object.assign(this, createBookDto)
  }

  @Property()
  titles?: string[]

  @Property()
  authors?: Author[]

  @Property()
  publishers?: Publisher[]

  @Property()
  isbn?: string

}

Service Implementation

Now implement the services:

Author

import { Injectable } from '@nestjs/common'
import { EntityManager } from '@mikro-orm/core'
import { Author } from './entities/author.entity'
import { CreateAuthorDto } from './dto/create-author.dto'
import { UpdateAuthorDto } from './dto/update-author.dto'

@Injectable()
export class AuthorService {
  constructor(private readonly authorRepository: EntityManager) { }

  async create(createAuthorDto: CreateAuthorDto): Promise {
    const newAuthor = new Author(createAuthorDto)
    await this.authorRepository.persistAndFlush(newAuthor)
    return newAuthor
  }

  async findAll(query: Record<string, any> = {}): Promise<Author[]> {
    return await this.authorRepository.find(Author, query)
  }

  async findOne(id: string): Promise {
    return this.authorRepository.findOneOrFail(Author, id)
  }

  async update(id: string, updateAuthorDto: UpdateAuthorDto): Promise {
    return await this.authorRepository.transactional(async (em) => {
      const author = await em.findOneOrFail(Author, id)
      Object.assign(author, updateAuthorDto, { merge: true })
      await em.persistAndFlush(author)
      return author
    })
  }

  async remove(id: string): Promise {
    const author = await this.authorRepository.findOneOrFail(Author, id)
    await this.authorRepository.removeAndFlush(author)
    return author
  }

}

Publisher

import { Injectable } from '@nestjs/common'
import { Publisher } from './entities/publisher.entity'
import { CreatePublisherDto } from './dto/create-publisher.dto'
import { UpdatePublisherDto } from './dto/update-publisher.dto'
import { EntityManager } from '@mikro-orm/core'

@Injectable()
export class PublisherService {
  constructor(private readonly publisherRepository: EntityManager) { }

  async create(createPublisherDto: CreatePublisherDto) {
    const publisher = new Publisher(createPublisherDto)
    await this.publisherRepository.persistAndFlush(publisher)
    return publisher
  }

  async findAll(query: Record<string, any> = {}): Promise<Publisher[]> {
    return this.publisherRepository.find(Publisher, query)
  }

  async findOne(id: string): Promise {
    return this.publisherRepository.findOneOrFail(Publisher, id)
  }

  async update(id: string, updatePublisherDto: UpdatePublisherDto): Promise {
    return await this.publisherRepository.transactional(async (em) => {
      const publisher = await em.findOneOrFail(Publisher, { id })
      Object.assign(publisher, updatePublisherDto, { merge: true })
      await em.persistAndFlush(publisher)
      return publisher
    })
  }

  async remove(id: string): Promise {
    const publisher = await this.publisherRepository.findOneOrFail(Publisher, id)
    await this.publisherRepository.removeAndFlush(publisher)
    return publisher
  }
}

Book

The book is a little bit different, because it unidirectionally links to Publisher and Author.

import { Injectable, Logger, NotFoundException } from '@nestjs/common'
import { Book } from './entities/book.entity'
import { CreateBookDto } from './dto/create-book.dto'
import { UpdateBookDto } from './dto/update-book.dto'
import { EntityManager } from '@mikro-orm/core'
import { Publisher } from '../publisher/entities/publisher.entity'
import { Author } from '../author/entities/author.entity'

@Injectable()
export class BookService {
  private readonly logger = new Logger(BookService.name)
  constructor(private readonly em: EntityManager) { }

  async create(createBookDto: CreateBookDto): Promise {
    return await this.em.transactional(async (em) => {
      const authors = await em.find(Author, { id: { $in: createBookDto.authors ?? [] } })
      if ((authors?.length ?? 0) !== (createBookDto?.authors?.length ?? 0)) throw new NotFoundException('author not found')
      const publishers = await em.find(Publisher, { id: { $in: createBookDto.publishers ?? [] } })
      if ((publishers?.length ?? 0) !== (createBookDto?.publishers?.length ?? 0)) throw new NotFoundException('publisher not found')
      const book = new Book(createBookDto, authors, publishers);
      await em.persistAndFlush(book);
      return book;
    })
  }

  async findAll(query: Object = {}): Promise<Book[]> {
    return this.em.find(Book, query, { populate: ['authors', 'publishers'] })
  }

  async findOne(id: string): Promise {
    return this.em.findOneOrFail(Book, id, { populate: ['authors', 'publishers'] })
  }

  async update(id: string, updateBookDto: UpdateBookDto): Promise {
    return await this.em.transactional(async (em) => {
      const authors = await em.find(Author, { id: { $in: updateBookDto.authors ?? [] } })
      if ((authors?.length ?? 0) !== (updateBookDto?.authors?.length ?? 0)) throw new NotFoundException('author not found')
      const publishers = await em.find(Publisher, { id: { $in: updateBookDto.publishers ?? [] } })
      if ((publishers?.length ?? 0) !== (updateBookDto?.publishers?.length ?? 0)) throw new NotFoundException('publisher not found')
      const book = await em.findOneOrFail(Book, { id })
      Object.assign(book, {
        ...updateBookDto,
        authors: updateBookDto.authors === null ? book.authors : authors,
        publishers: updateBookDto.publishers === null ? book.publishers : publishers
      })
      await em.persistAndFlush(book)
      return book
    })
  }

  async remove(id: string): Promise {
    const book = await this.em.findOneOrFail(Book, id)
    await this.em.removeAndFlush(book)
    return book
  }
}

Initial Migration

After all entities have been defined, you are ready to create an initial migration. This migration creates database tables for the entities plus an additional table to keep track of the migrations.

Install the TypeORM command line tool:

npm i -D @mikro-orm/cli

Create a configuration file mikro-orm.config.ts. This file is used in the command line interface and can be different to the configuration in your code. This is especially useful, when you run a real SQL database, such as MariaDB, then just specify localhost:3306, a dummy password, and run a database from Docker. For SQLite configuration can be:

import { TsMorphMetadataProvider } from "@mikro-orm/reflection"

export default {
    entities: [
        'dist/src/**/entities/*.entity.js'
    ],
    entitiesTs: [
        'src/**/entities/*.entity.ts'
    ],
    type: 'sqlite',
    dbName: 'test-db.sqlite3',
    metadataProvider: TsMorphMetadataProvider,
    migrations: {
        path: 'migrations',
    }
}

Tell MikroOrm to use a TypeScript file in `package.json` add:

  "mikro-orm": {
    "useTsNode": true,
    "configPaths": [
      "./mikro-orm.config.ts"
    ]
  }

Finally create your initial migration:

npx mikro-orm migration:create --initial

A JSON schema file and a new migrations file is created in path migrations. Check them in the editor.

Please be aware, that you need to to create a new migration, whenever you change anything in the entities. You should always check the generated result and manually fix the migration file if necessary.

As long as you haven’t released a migration to production yet, and no importatnt data is depending on it, you may remove and recreate the migration files. But never do this, when a database with production data already run this specific migration. Otherwise, you have to make sure, you don’t mess up with the different versions of your schemas.

Run

Now just run it:

npm start

Then head your browser to the API documentation and play with it:

https://localhost:4000/api

Go to «PATCH /author», klick «Try it out», set the message body to:

{
  "first_names": [
    "Marc", "Roman"
  ],
  "last_names": [
    "Wäckerlin"
  ],
  "born": "1971-05-30"
}

and execute it. You may create other authors, or even the same multiple times, since not the name, but a unique uuid identifies the data. Then execute «GET /author» to verify that your authors have been stored. Feel free to also test the other functions.