Managing MongoDB Records Using NestJS and Mongoose

NestJS is a framework for developing Node.js-based applications. It provides an additional abstraction layer on top of Express or other HTTP handlers and gives developers a stable foundation to build applications with structured procedures. Meanwhile, Mongoose is a schema modeling helper based on Node.js for MongoDB.

There are several main steps to be performed for allowing our program to handle MongoDB records. First, we need to add the dependencies which are @nestjs/mongoose, mongoose, and @types/mongoose. Then, we need to define the connection configuration on the application module decorator.

import { MongooseModule } from '@nestjs/mongoose';

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost:27017/mydb'),
  ],
  controllers: [AppController],
  providers: [AppService],
})

Next, we create the schema definition using helpers provided by NestJS and Mongoose. The following snippet is an example with a declaration of index setting and an object as the value of a field.

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { SchemaTypes, Document } from 'mongoose';

@Schema()
export class User extends Document {
  @Prop()
  name: string;

  @Prop({ index: true }) // set index individually
  type: string;

  @Prop(SchemaTypes.Mixed) // a value with type of object
  payload: Record<string, any>;
}

export const UserSchema = SchemaFactory.createForClass(User);
UserSchema.index({ name: 1, type: -1 }); // set compound index

Now, we can set the schema as a property for the Mongoose module imported into any application module.

//...
  imports: [
    MongooseModule.forFeature([
      {
        name: User.name,
        schema: UserSchema,
      },
    ]),
  ],
//...

Finally, we can inject the model of our schema into a component in our application. For instance, we will inject it into a service using the InjectModel decorator.

import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';

@Injectable()
export class UserService {
  constructor(
    @InjectModel(User.name) private readonly userModel: Model<User>,
  ) {}

  findAll() {
    return this.userModel
      .find()
      .skip(0)
      .limit(10)
      .exec();
  }
  
  create(data) {
    const user = new this.userModel(data);
    return user.save();
  }
  
  async update(id: string, data) {
    const existingUser = this.userModel
      .findOneAndUpdate({ _id: id }, { $set: data }, { new: true }) // return the updated object
      .exec();

    if (!existingUser) {
      throw new NotFoundException();
    }

    return existingUser;
  }
  //...

Additionally, in a database operation, we may be required to perform a transaction that updates records in several collections. We can realize it by injecting a connection to our service and creating a session for the transaction.

import { InjectModel, InjectConnection } from '@nestjs/mongoose';
import { Model, Connection } from 'mongoose';

@Injectable()
export class TeaService {
  constructor(
    @InjectModel(User.name) private readonly userModel: Model<User>,
    @InjectModel(Related.name) private readonly relatedModel: Model<Related>, // an example of another schema
    @InjectConnection() private readonly connection: Connection,
  ) {}
  // ...
  
  async duSomething(user: User) {
    const session = await this.connection.startSession();
    session.startTransaction();

    try {
      user.numberOfRelation++; // an example of a field update
      
      const related = new this.relatedModel({
        name: 'something',
        payload: { userId: user._id },
      });

      await related.save({ session });
      await user.save({ session });

      await session.commitTransaction();
    } catch (error) {
      await session.abortTransaction();
    } finally {
      session.endSession();
    }
  }