MongoDB (Mongoose)

Mongoose est l’outil de modélisation d’objet MongoDB le plus populaire.

Getting started

Pour commencer l’aventure avec cette bibliothèque, nous devons installer toutes les dépendances requises :

$ npm install --save mongoose

La première étape consiste à établir la connexion avec notre base de données en utilisant la fonction connect(). La fonction connect() renvoie une Promise. Par conséquent, nous devons créer un provider asynchrone.

import * as mongoose from 'mongoose';

export const databaseProviders = [
  {
    provide: 'DATABASE_CONNECTION',
    useFactory: (): Promise<typeof mongoose> =>
      mongoose.connect('mongodb://localhost/nest'),
  },
];

Ensuite, nous devons exporter ces fournisseurs pour les rendre accessibles au reste de l’application.

import { Module } from '@nestjs/common';
import { databaseProviders } from './database.providers';

@Module({
  providers: [...databaseProviders],
  exports: [...databaseProviders],
})
export class DatabaseModule {}

Maintenant, nous pouvons injecter l’objet Connection en utilisant le décorateur @Inject(). Chaque classe qui dépendra du provider asynchrone Connection attendra qu’une Promise soit résolue.

Model injection

Avec Mongoose, tout est dérivé d’un Schema. Définissons le CatSchema :

import * as mongoose from 'mongoose';

export const CatSchema = new mongoose.Schema({
  name: String,
  age: Number,
  breed: String,
});

Le CatsSchema appartient au répertoire cats. Ce répertoire représente le CatsModule.

Il est maintenant temps de créer un provider de Model :

import { Connection } from 'mongoose';
import { CatSchema } from './schemas/cat.schema';

export const catsProviders = [
  {
    provide: 'CAT_MODEL',
    useFactory: (connection: Connection) =>
      connection.model('Cat', CatSchema),
    inject: ['DATABASE_CONNECTION'],
  },
];

Nous pouvons maintenant injecter le CAT_MODEL dans le CatsService en utilisant le décorateur @Inject() :

import { Model } from 'mongoose';
import { Injectable, Inject } from '@nestjs/common';
import { Cat } from './interfaces/cat.interface';
import { CreateCatDto } from './dto/create-cat.dto';

@Injectable()
export class CatsService {
  constructor(
    @Inject('CAT_MODEL') private catModel: Model<Cat>,
  ) {}

  async create(createCatDto: CreateCatDto): Promise<Cat> {
    const createdCat = new this.catModel(createCatDto);
    return createdCat.save();
  }

  async findAll(): Promise<Cat[]> {
    return this.catModel.find().exec();
  }
}

Dans l’exemple ci-dessus, nous avons utilisé l’interface Cat. Cette interface étend le Document du package mongoose :

import { Document } from 'mongoose';

export interface Cat extends Document {
  readonly name: string;
  readonly age: number;
  readonly breed: string;
}

La connexion à la base de données est asynchrone, mais Nest rend ce processus complètement invisible pour l’utilisateur final. La classe CatModel attend la connexion à la base de données, et le CatsService est retardé jusqu’à ce que le modèle soit prêt à être utilisé. L’ensemble de l’application peut démarrer lorsque chaque classe est instanciée.

Voici un dernier CatsModule :

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';
import { catsProviders } from './cats.providers';
import { DatabaseModule } from '../database/database.module';

@Module({
  imports: [DatabaseModule],
  controllers: [CatsController],
  providers: [
    CatsService,
    ...catsProviders,
  ],
})
export class CatsModule {}

Exemple

Un exemple fonctionnel est disponible ici.