MikroORM

https://mikro-orm.io/docs
Admin
MikroORM is a TypeScript ORM that supports multiple databases including MongoDB, MySQL, PostgreSQL,...
Tokens:487,391
Snippets:3,787
Trust Score:8.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Clone the MikroORM guide repository

Source: https://mikro-orm.io/docs/guide

Clones the final project repository for the Getting Started Guide. Use this to inspect the complete application built throughout the tutorial.

```bash
git clone https://github.com/mikro-orm/guide.git
```

--------------------------------

### MikroORM + Hapi Plugin Setup

Source: https://mikro-orm.io/docs/usage-with-adminjs

Sets up AdminJS with MikroORM and the Hapi plugin. Initializes MikroORM, registers the adapter, registers AdminJS as a Hapi plugin, and starts the server.

```typescript
import AdminJS from 'adminjs';

import { Database, Resource } from '@adminjs/mikroorm';

import AdminJSHapi from '@adminjs/hapi';

import { MikroORM } from '@mikro-orm/postgresql';

import { validate } from 'class-validator'; // optional



const PORT = process.env.PORT ?? 3000;



const run = async () => {

  /* Initialize MikroORM like you would do normally, you can also import your MikroORM instance from a separate file */

  const orm = await MikroORM.init({

    entities: [User, Car, Seller], // use your own entities

    dbName: process.env.DATABASE_NAME,

    clientUrl: process.env.DATABASE_URL,

  });



  /* Optional: if you're using class-validator, assign it to Resource */

  Resource.validate = validate;

  /* Tell AdminJS which adapter to use */

  AdminJS.registerAdapter({ Database, Resource });



  const server = Hapi.server({ port: PORT })



  /* Configure AdminJS */

  const adminOptions = {

    databases: [orm],

  };



  /* Register AdminJS as a Hapi server's plugin */

  await server.register({

    plugin: AdminJSHapi,

    options: adminOptions,

  });



  await server.start();

  console.log(`App listening at ${server.info.uri}`);

}



run();
```

--------------------------------

### MikroORM + Express Plugin Setup

Source: https://mikro-orm.io/docs/usage-with-adminjs

Sets up AdminJS with MikroORM and the Express plugin. Initializes MikroORM, registers the adapter, builds the router, and starts the server on the configured port.

```typescript
import AdminJS from 'adminjs';

import { Database, Resource } from '@adminjs/mikroorm';

import AdminJSExpress from '@adminjs/express';

import { MikroORM } from '@mikro-orm/postgresql';

import { validate } from 'class-validator'; // optional



const PORT = process.env.PORT ?? 3000;



const run = async () => {

  /* Initialize MikroORM like you would do normally, you can also import your MikroORM instance from a separate file */

  const orm = await MikroORM.init({

    entities: [User, Car, Seller], // use your own entities

    dbName: process.env.DATABASE_NAME,

    clientUrl: process.env.DATABASE_URL,

  });



  /* Optional: if you're using class-validator, assign it to Resource */

  Resource.validate = validate;

  /* Tell AdminJS which adapter to use */

  AdminJS.registerAdapter({ Database, Resource });



  const app = express();



  /* Create AdminJS instance */

  const admin = new AdminJS({

    databases: [orm],

  });



  const router = AdminJSExpress.buildRouter(admin);



  app.use(admin.options.rootPath, router);



  app.listen(PORT, () => {

    console.log(`App listening at http://localhost:${PORT}`);

  });

}



run();
```

--------------------------------

### Install @mikro-orm/libsql with Bun

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the core and libSQL packages using Bun.

```bash
bun add @mikro-orm/core @mikro-orm/libsql
```

--------------------------------

### Install @mikro-orm/sql-js with Bun

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the sql.js driver packages using Bun.

```bash
bun add @mikro-orm/core @mikro-orm/sql-js
```

--------------------------------

### Install reflect-metadata with Bun

Source: https://mikro-orm.io/docs/using-decorators

Install the reflect-metadata package using Bun.

```bash
bun add reflect-metadata
```

--------------------------------

### Install production dependencies with Bun

Source: https://mikro-orm.io/docs/guide/first-entity

Install core MikroORM, SQLite driver, and Fastify using Bun.

```bash
bun add @mikro-orm/core \

            @mikro-orm/sqlite \

            fastify
```

--------------------------------

### Initialize ORM with generated entities and start Fastify app

Source: https://mikro-orm.io/docs/schema-first-guide

These files form the application setup for using the generated entities: the database wrapper (src/db.ts), the Fastify app bootstrap (src/app.ts), the server entry point (src/server.ts), and the package.json scripts. The db.ts initializes the ORM with the generated entities and exposes repositories; app.ts sets up request context and a sample /article route; server.ts starts the app; package.json adds check and start scripts.

```typescript
import {

  type EntityManager,

  type EntityRepository,

  MikroORM,

  type Options,

} from "@mikro-orm/mysql";

import config from "./mikro-orm.config.js";

import { Article } from "./modules/article/article.entity.js";

import { Tag } from "./modules/article/tag.entity.js";

import { User } from "./modules/user/user.entity.js";

import { Comment } from "./modules/article/comment.entity.js";



export interface Services {

  orm: MikroORM;

  em: EntityManager;

  user: EntityRepository<User>;

  article: EntityRepository<Article>;

  tag: EntityRepository<Tag>;

  comment: EntityRepository<Comment>;

}



let cache: Services;



export async function initORM(options?: Partial<Options>): Promise<Services> {

  if (cache) {

    return cache;

  }



  const orm = await MikroORM.init({

    ...config,

    ...options,

  });



  return (cache = {

    orm,

    em: orm.em,

    user: orm.em.getRepository(User),

    article: orm.em.getRepository(Article),

    tag: orm.em.getRepository(Tag),

    comment: orm.em.getRepository(Comment),

  });

}
```

```typescript
import { RequestContext } from '@mikro-orm/core';

import { fastify } from 'fastify';

import { initORM } from './db.js';



export async function bootstrap(port = 3001, migrate = true) {

  const db = initORM({

      ensureDatabase: { create: false },

  });



  if (migrate) {

    // sync the schema

    await db.orm.migrator.up();

  }



  const app = fastify();



  // register request context hook

  app.addHook('onRequest', (request, reply, done) => {

    RequestContext.create(db.em, done);

  });



  // shut down the connection when closing the app

  app.addHook('onClose', async () => {

    await db.orm.close();

  });



  // register routes here

  app.get('/article', async (request) => {

    const { limit, offset } = request.query as {

      limit?: number;

      offset?: number;

    };

    const [items, total] = await db.article.findAndCount(

      {},

      {

        limit,

        offset,

      }

    );



    return { items, total };

  });



  const url = await app.listen({ port });



  return { app, url };

}
```

```typescript
import { bootstrap }  from './app.js';



try {

  const { url } = await bootstrap();

  console.log(`server started at ${url}`);

} catch (e) {

  console.error(e);

}
```

```json
{

  "scripts": {

    "check": "tsc --noEmit",

    "start": "tsx src/server.ts"

  }

}
```

--------------------------------

### Install @mikro-orm/pglite with Bun

Source: https://mikro-orm.io/docs/usage-with-pglite

Install the core and PGlite driver packages using Bun.

```bash
bun add @mikro-orm/core @mikro-orm/pglite
```

--------------------------------

### Install @mikro-orm/sql and kysely with Bun

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the node:sqlite driver packages using Bun.

```bash
bun add @mikro-orm/core @mikro-orm/sql kysely
```

--------------------------------

### Install @mikro-orm/libsql with npm

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the core and libSQL packages using npm.

```bash
npm install @mikro-orm/core @mikro-orm/libsql
```

--------------------------------

### Install production dependencies with pnpm

Source: https://mikro-orm.io/docs/guide/first-entity

Install core MikroORM, SQLite driver, and Fastify using pnpm.

```bash
pnpm add @mikro-orm/core \

            @mikro-orm/sqlite \

            fastify
```

--------------------------------

### Install @mikro-orm/sqlite with Bun

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the core and SQLite packages using Bun.

```bash
bun add @mikro-orm/core @mikro-orm/sqlite
```

--------------------------------

### Install @mikro-orm/libsql with Yarn

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the core and libSQL packages using Yarn.

```bash
yarn add @mikro-orm/core @mikro-orm/libsql
```

--------------------------------

### Install @mikro-orm/sql-js with npm

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the sql.js driver packages using npm.

```bash
npm install @mikro-orm/core @mikro-orm/sql-js
```

--------------------------------

### Install @mikro-orm/libsql with pnpm

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the core and libSQL packages using pnpm.

```bash
pnpm add @mikro-orm/core @mikro-orm/libsql
```

--------------------------------

### Install reflect-metadata with npm

Source: https://mikro-orm.io/docs/using-decorators

Install the reflect-metadata package using npm.

```bash
npm install reflect-metadata
```

--------------------------------

### Install MikroORM and kysely-durable-objects with Bun

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the required packages using Bun: @mikro-orm/core, @mikro-orm/sql, kysely, and kysely-durable-objects.

```bash
bun add @mikro-orm/core @mikro-orm/sql kysely kysely-durable-objects
```

--------------------------------

### Install production dependencies with npm

Source: https://mikro-orm.io/docs/guide/first-entity

Install core MikroORM, SQLite driver, and Fastify using npm.

```bash
npm install @mikro-orm/core \

            @mikro-orm/sqlite \

            fastify
```

--------------------------------

### Install @mikro-orm/sql-js with Yarn

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the sql.js driver packages using Yarn.

```bash
yarn add @mikro-orm/core @mikro-orm/sql-js
```

--------------------------------

### Install production dependencies with Yarn

Source: https://mikro-orm.io/docs/guide/first-entity

Install core MikroORM, SQLite driver, and Fastify using Yarn.

```bash
yarn add @mikro-orm/core \

            @mikro-orm/sqlite \

            fastify
```

--------------------------------

### Install @mikro-orm/pglite with npm

Source: https://mikro-orm.io/docs/usage-with-pglite

Install the core and PGlite driver packages using npm.

```bash
npm install @mikro-orm/core @mikro-orm/pglite
```

--------------------------------

### Install @mikro-orm/sql and kysely with npm

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the node:sqlite driver packages using npm.

```bash
npm install @mikro-orm/core @mikro-orm/sql kysely
```

--------------------------------

### Install runtime dependencies with npm, Yarn, pnpm, or Bun

Source: https://mikro-orm.io/docs/schema-first-guide

Installs the required runtime dependencies: MikroORM core, MySQL driver, migrations, and Fastify. Use the command that matches your package manager.

```bash
npm install @mikro-orm/core \
            @mikro-orm/mysql \
            @mikro-orm/migrations \
            fastify
```

```bash
yarn add @mikro-orm/core \
            @mikro-orm/mysql \
            @mikro-orm/migrations \
            fastify
```

```bash
pnpm add @mikro-orm/core \
            @mikro-orm/mysql \
            @mikro-orm/migrations \
            fastify
```

```bash
bun add @mikro-orm/core \
            @mikro-orm/mysql \
            @mikro-orm/migrations \
            fastify
```

--------------------------------

### Install @mikro-orm/sql and kysely with pnpm

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the node:sqlite driver packages using pnpm.

```bash
pnpm add @mikro-orm/core @mikro-orm/sql kysely
```

--------------------------------

### Install @mikro-orm/sql and kysely with Yarn

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the node:sqlite driver packages using Yarn.

```bash
yarn add @mikro-orm/core @mikro-orm/sql kysely
```

--------------------------------

### Clone the schema-first guide repository

Source: https://mikro-orm.io/docs/schema-first-guide

Clone the final project repository to inspect the complete schema-first application.

```bash
git clone https://github.com/mikro-orm/schema-first-guide.git
```

--------------------------------

### Install MikroORM and kysely-durable-objects with Yarn

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the required packages using Yarn: @mikro-orm/core, @mikro-orm/sql, kysely, and kysely-durable-objects.

```bash
yarn add @mikro-orm/core @mikro-orm/sql kysely kysely-durable-objects
```

--------------------------------

### Install MikroORM and kysely-durable-objects with pnpm

Source: https://mikro-orm.io/docs/usage-with-sqlite

Install the required packages using pnpm: @mikro-orm/core, @mikro-orm/sql, kysely, and kysely-durable-objects.

```bash
pnpm add @mikro-orm/core @mikro-orm/sql kysely kysely-durable-objects
```

--------------------------------

### Install pluralize package

Source: https://mikro-orm.io/docs/schema-first-guide

Install the pluralize package and its type definitions as dev dependencies using your preferred package manager.

```bash
npm install --save-dev pluralize @types/pluralize
```

```bash
yarn add --dev pluralize @types/pluralize
```

```bash
pnpm add --save-dev pluralize @types/pluralize
```

```bash
bun add --dev pluralize @types/pluralize
```

--------------------------------

### Create and enter project directory

Source: https://mikro-orm.io/docs/schema-first-guide

Creates a new directory named blog-api and changes into it. Run this before initializing the project.

```bash
mkdir blog-api && cd blog-api
```

--------------------------------

### Install dev dependencies with npm, Yarn, pnpm, or Bun

Source: https://mikro-orm.io/docs/schema-first-guide

Installs development dependencies: MikroORM CLI, entity generator, TypeScript, tsx, Node types, rimraf, and vitest. Use the command that matches your package manager.

```bash
npm install --save-dev @mikro-orm/cli \
                       @mikro-orm/entity-generator \
                       typescript \
                       tsx \
                       @types/node \
                       rimraf \
                       vitest
```

```bash
yarn add --dev @mikro-orm/cli \
                       @mikro-orm/entity-generator \
                       typescript \
                       tsx \
                       @types/node \
                       rimraf \
                       vitest
```

```bash
pnpm add --save-dev @mikro-orm/cli \
                       @mikro-orm/entity-generator \
                       typescript \
                       tsx \
                       @types/node \
                       rimraf \
                       vitest
```

```bash
bun add --dev @mikro-orm/cli \
                       @mikro-orm/entity-generator \
                       typescript \
                       tsx \
                       @types/node \
                       rimraf \
                       vitest
```

--------------------------------

### Add build and start:prod scripts to package.json

Source: https://mikro-orm.io/docs/schema-first-guide

Adds build and production start scripts to package.json. The build script runs tsc --build to emit JavaScript, and start:prod runs the compiled server with node instead of tsx.

```json
"scripts": {

  "build": "tsc --build",

  "start:prod": "node ./dist/server.js",

  ...

}
```

--------------------------------

### Install argon2 with npm, Yarn, pnpm, or Bun

Source: https://mikro-orm.io/docs/schema-first-guide

Install argon2 as the hashing function for the custom password type. The four commands are equivalent package manager alternatives.

```bash
npm install argon2
```

```bash
yarn add argon2
```

```bash
pnpm add argon2
```

```bash
bun add argon2
```

--------------------------------

### Configure migrations options in MikroORM.init()

Source: https://mikro-orm.io/docs/configuration

Configure the migrations namespace in MikroORM.init(). Shows all possible options and their defaults, including the migrations table name, path, glob pattern, transactional execution, foreign key checks, all-or-nothing behavior, and migration generation mode.

```javascript
MikroORM.init({

  migrations: {

    tableName: 'mikro_orm_migrations', // migrations table name

    path: process.cwd() + '/migrations', // path to folder with migration files

    glob: '!(*.d).{js,ts}', // how to match migration files (all .js and .ts files, but not .d.ts)

    transactional: true, // run each migration inside transaction

    disableForeignKeys: true, // try to disable foreign_key_checks (or equivalent)

    allOrNothing: true, // run all migrations in current batch in master transaction

    emit: 'ts', // migration generation mode

  },

});
```

--------------------------------

### Define entity with decorators

Source: https://mikro-orm.io/docs/quick-start

Use decorators like `@Entity`, `@PrimaryKey`, `@Property`, `@ManyToOne`, and `@ManyToMany` to define an entity. Requires additional setup as described in the Using Decorators guide.

```typescript
import { Collection } from '@mikro-orm/core';

import { Entity, PrimaryKey, Property, ManyToOne, ManyToMany } from '@mikro-orm/decorators/legacy';



@Entity()

export class Book {



  @PrimaryKey()

  id!: bigint;



  @Property()

  title!: string;



  @ManyToOne(() => Author)

  author!: Author;



  @ManyToMany(() => BookTag)

  tags = new Collection<BookTag>(this);



}
```

--------------------------------

### Install renamer with different package managers

Source: https://mikro-orm.io/docs/schema-first-guide

Install the renamer package as a dev dependency using npm, Yarn, pnpm, or Bun. This is needed to rename custom entity files before and after regeneration.

```bash
npm install --save-dev renamer
```

```bash
yarn add --dev renamer
```

```bash
pnpm add --save-dev renamer
```

```bash
bun add --dev renamer
```

--------------------------------

### State Methods - isInitialized and init

Source: https://mikro-orm.io/docs/wrap-helper

Shows how to check if an entity is initialized and load it using wrap().init(). The example uses em.getReference to get a reference, then checks isInitialized() before and after calling init().

```typescript
const author = em.getReference(Author, 1);

wrap(author).isInitialized(); // false - just a reference



await wrap(author).init();

wrap(author).isInitialized(); // true - now loaded
```

--------------------------------

### Set up MongoDB replica set and initialize MikroORM with implicit transactions

Source: https://mikro-orm.io/docs/usage-with-mongo

First create a replica set with run-rs, then initialize MikroORM with the MongoDB driver, enabling implicit transactions and creating all collections explicitly with orm.schema.create().

```bash
# first create replica set

$ run-rs -v 4.2.3
```

```typescript
// make sure to import from the MongoDriver package

import { MikroORM } from '@mikro-orm/mongodb';



const orm = await MikroORM.init({

  entities: [Author, Book, ...],

  clientUrl: 'mongodb://localhost:27017,localhost:27018,localhost:27019/my-db-name?replicaSet=rs0',

  implicitTransactions: true, // defaults to false

});



await orm.schema.create();
```

--------------------------------

### Create project folder structure

Source: https://mikro-orm.io/docs/guide/first-entity

Initialize the project directory and create the module subdirectories for user, article, and common modules.

```bash
# create the project folder and `cd` into it

mkdir blog-api && cd blog-api

# create module folders, inside `src` folder

mkdir -p src/modules/{user,article,common}
```

--------------------------------

### Configure TypeScript in tsconfig.json

Source: https://mikro-orm.io/docs/schema-first-guide

TypeScript configuration for the project. Adjust as needed; this is similar to the one in the code-first guide.

```json
{
  "compilerOptions": {
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "target": "ES2024",
    "strict": true,
    "outDir": "dist",
    "declaration": true
  },
  "include": [
    "./src/**/*.ts"
  ]
}
```

--------------------------------

### QueryBuilder select example

Source: https://mikro-orm.io/docs/usage-with-sql

Creates a QueryBuilder for the Author entity, selects all columns, filters by name with a LIKE pattern, orders by name, limits to 10 results, and executes the query to get the result list.

```typescript
const qb = em.createQueryBuilder(Author);

qb.select('*')

  .where({ name: { $like: '%test%' } })

  .orderBy({ name: 'asc' })

  .limit(10);



const authors = await qb.getResultList();
```

--------------------------------

### Use MikroORM BaseEntity

Source: https://mikro-orm.io/docs/defining-entities

Shows how to extend MikroORM's BaseEntity to get methods like init, isInitialized, and assign. Usage is optional. The example creates a Book instance and logs isInitialized() which returns true.

```typescript
import { BaseEntity } from '@mikro-orm/core';



@Entity()

export class Book extends BaseEntity {



  @PrimaryKey()

  id!: number;



  @Property()

  title!: string;



  @ManyToOne()

  author!: Author;



}



const book = new Book();

console.log(book.isInitialized()); // true
```

--------------------------------

### Log output for em.refresh()

Source: https://mikro-orm.io/docs/guide/first-entity

Expected log output after running `npm start` with the refresh example. It shows the select query from `em.refresh()`, the entity with the original bio, and the subsequent update query after flushing the new change.

```text
[query] select `u0`.* from `user` as `u0` where `u0`.`id` = 1 limit 1 [took 1 ms, 1 result]

changes are lost User {

  fullName: 'Foo Bar',

  email: 'foo@bar.com',

  password: '123456',

  bio: '...',

  id: 1

}

[query] begin

[query] update `user` set `bio` = 'some change, will be saved' where `id` = 1 [took 0 ms, 1 row affected]

[query] commit
```

--------------------------------

### Environment-dependent MikroORM config (src/mikro-orm.config.ts)

Source: https://mikro-orm.io/docs/schema-first-guide

Configures MikroORM to detect CLI usage and conditionally enable the entity generator, disable entity discovery during generate-entities, and enable multipleStatements only in the CLI. Requires the '@mikro-orm/entity-generator' package to be installed.

```typescript
import {

    defineConfig,

    type MikroORMOptions,

} from '@mikro-orm/mysql';

import { UnderscoreNamingStrategy } from '@mikro-orm/core';

import { Migrator } from '@mikro-orm/migrations';

import pluralize from 'pluralize';

import { join } from 'node:path';



const isInMikroOrmCli = process.argv[1]?.endsWith(join('@mikro-orm', 'cli', 'esm')) ?? false;

const isRunningGenerateEntities = isInMikroOrmCli && process.argv[2] === 'generate-entities';



const mikroOrmExtensions: MikroORMOptions['extensions'] = [Migrator];

if (isInMikroOrmCli) {

    mikroOrmExtensions.push((await import('@mikro-orm/entity-generator')).EntityGenerator);

}



export default defineConfig({

  extensions: mikroOrmExtensions,

  multipleStatements: isInMikroOrmCli,

  discovery: {

    warnWhenNoEntities: !isInMikroOrmCli,

  },

  entities: isRunningGenerateEntities ? [] : ['dist/**/*.customEntity.js', 'dist/**/*.entity.js'],

  entitiesTs: isRunningGenerateEntities ? [] : ['src/**/*.customEntity.ts', 'src/**/*.entity.ts'],

  // rest of the config

});
```

--------------------------------

### Full example with defineEntity and CockroachDB

Source: https://mikro-orm.io/docs/usage-with-cockroachdb

Full example using defineEntity to define Author and Book entities, then initializing MikroORM with CockroachDB connection settings (port 26257, user root), updating the schema, creating and flushing entities, and querying with populate.

```typescript
const Author = defineEntity({

  name: 'Author',

  properties: {

    id: p.uuid().primary(),

    name: p.string(),

    email: p.string(),

    books: () => p.oneToMany(Book).mappedBy('author'),

  },

});



const Book = defineEntity({

  name: 'Book',

  properties: {

    id: p.uuid().primary(),

    title: p.string(),

    author: () => p.manyToOne(Author),

  },

});



const orm = await MikroORM.init({

  entities: [Author, Book],

  dbName: 'my_database',

  host: 'localhost',

  port: 26257,

  user: 'root',

  password: '',

});



await orm.schema.update();



const em = orm.em.fork();

const author = em.create(Author, { name: 'John', email: 'john@example.com' });

em.create(Book, { title: 'My Book', author });

await em.flush();



const books = await em.find(Book, {}, { populate: ['author'] });

console.log(books[0].author.name); // 'John'



await orm.close();
```

--------------------------------

### Install AdminJS Core

Source: https://mikro-orm.io/docs/usage-with-adminjs

Installs the AdminJS core package.

```bash
$ yarn add adminjs
```

--------------------------------

### Add article endpoints with Zod validation in article.routes.ts

Source: https://mikro-orm.io/docs/schema-first-guide

Adds article endpoints to the article routes file: GET /:slug returns an article with author, comments, and text populated; POST /:slug/comment creates a comment and flushes the entity manager. The second block adds POST / to create an article, but it triggers a type error because slug and description are required in the entity.

```typescript
// rest of the code



  const articleBySlugParams = z.object({

    slug: z.string().min(1),

  });

  

  app.get('/:slug', async request => {

    const { slug } = articleBySlugParams.parse(request.params);

    return db.article.findOneOrFail({ slug }, {

      populate: ['author', 'commentCollection.author', 'text'],

    });

  });



  const articleCommentPayload = z.object({

    text: z.string().min(1),

  });

  

  app.post('/:slug/comment', async request => {

    const { slug } = articleBySlugParams.parse(request.params);

    const { text } = articleCommentPayload.parse(request.body);

    const author = getUserFromToken(request);

    const article = await db.article.findOneOrFail({ slug });

    const comment = db.comment.create({ author, article, text });

  

    // We can add the comment to `article.comments` collection,

    // but in fact it is a no-op, as it will be automatically

    // propagated by setting Comment.author property.

    article.commentCollection.add(comment);

  

    // mention we don't need to persist anything explicitly

    await db.em.flush();

  

    return comment;

  });



// rest of the code
```

```typescript
// rest of the code above



  const newArticlePayload = z.object({

    title: z.string().min(1),

    text: z.string().min(1),

    description: z.string().min(1).optional(),

  });



  app.post('/', async request => {

    const { title, text, description } = newArticlePayload.parse(request.body);

    const author = getUserFromToken(request);

    const article = db.article.create({

      title,

      text,

      author,

      description,

    });

  

    await db.em.flush();

  

    return article;

  });

// rest of the code
```

--------------------------------

### Initialize project with npm, Yarn, pnpm, or Bun

Source: https://mikro-orm.io/docs/schema-first-guide

Initializes a new Node.js project using the package manager of your choice. Choose one of these commands.

```bash
npm init
```

```bash
yarn init
```

```bash
pnpm init
```

```bash
bun init
```

--------------------------------

### Install reflect-metadata with pnpm

Source: https://mikro-orm.io/docs/using-decorators

Install the reflect-metadata package using pnpm.

```bash
pnpm add reflect-metadata
```

--------------------------------

### Install reflect-metadata with Yarn

Source: https://mikro-orm.io/docs/using-decorators

Install the reflect-metadata package using Yarn.

```bash
yarn add reflect-metadata
```

--------------------------------

### Set up DI container and Fastify bootstrap with MikroORM

Source: https://mikro-orm.io/docs/guide/project-setup

Create a DI container in src/db.ts that initializes MikroORM once and caches the instance, then use it in app.ts to bootstrap a Fastify server with request context and a sample /article route.

```typescript
import { EntityManager, EntityRepository, MikroORM, Options } from '@mikro-orm/sqlite';

import { UserSchema, type User } from './modules/user/user.entity.js';

import { ArticleSchema, type IArticle } from './modules/article/article.entity.js';

import { TagSchema, type ITag } from './modules/article/tag.entity.js';

import config from './mikro-orm.config.js';



export interface Services {

  orm: MikroORM;

  em: EntityManager;

  article: EntityRepository<IArticle>;

  user: EntityRepository<User>;

  tag: EntityRepository<ITag>;

}



let cache: Services;



export function initORM(options?: Partial<Options>): Services {

  if (cache) {

    return cache;

  }



  const orm = new MikroORM({

    ...config,

    ...options,

  });



  // save to cache before returning

  return cache = {

    orm,

    em: orm.em,

    article: orm.em.getRepository(ArticleSchema),

    user: orm.em.getRepository(UserSchema),

    tag: orm.em.getRepository(TagSchema),

  };

}
```

```typescript
import { RequestContext } from '@mikro-orm/core';

import { fastify } from 'fastify';

import { initORM } from './db.js';



export async function bootstrap(port = 3001) {

  const db = initORM();

  const app = fastify();



  // register request context hook

  app.addHook('onRequest', (request, reply, done) => {

    RequestContext.create(db.em, done);

  });



  // shut down the connection when closing the app

  app.addHook('onClose', async () => {

    await db.orm.close();

  });



  // register routes here

  app.get('/article', async request => {

    const { limit, offset } = request.query as { limit?: number; offset?: number };

    const [items, total] = await db.article.findAndCount({}, {

      limit, offset,

    });



    return { items, total };

  });



  const url = await app.listen({ port });



  return { app, url };

}
```

--------------------------------

### Install @mikro-orm/core with additional packages

Source: https://mikro-orm.io/docs/usage-with-sql

Install @mikro-orm/core explicitly along with the driver and additional packages like @mikro-orm/migrations and @mikro-orm/cli to ensure all packages share the same instance. The driver package has @mikro-orm/core as a peer dependency, which most package managers install automatically, but explicit installation is recommended when using additional packages.

```bash
npm install @mikro-orm/core @mikro-orm/postgresql @mikro-orm/migrations @mikro-orm/cli
```

```bash
yarn add @mikro-orm/core @mikro-orm/postgresql @mikro-orm/migrations @mikro-orm/cli
```

```bash
pnpm add @mikro-orm/core @mikro-orm/postgresql @mikro-orm/migrations @mikro-orm/cli
```

```bash
bun add @mikro-orm/core @mikro-orm/postgresql @mikro-orm/migrations @mikro-orm/cli
```

--------------------------------

### Output of migration:up

Source: https://mikro-orm.io/docs/guide/project-setup

Example output of the migration:up command, showing the migration being applied.

```bash
npx mikro-orm migration:up



Processing 'Migration20220913205718'

Applied 'Migration20220913205718'

Successfully migrated up to the latest version
```
Tokens:
Raw