PassportLocalDocument and PaginateModel on the same interface? - node.js

Question

I am relatively new to typescript and NestJS framework. Currently I would like to implement a pagination mechanism for all models in my application. In the current api project I am using NestJS with mongoose.
My user schemma is the following
export const UserSchema = new mongoose.Schema({
firstName: String,
lastName: String,
email: String,
phone: String,
password: {
type: String
}
});
UserSchema.plugin(mongoosePaginate);
UserSchema.plugin(passportLocalMongoose, {
usernameField: 'email',
});
My user interface is the following:
export interface IUser extends PassportLocalDocument {
readonly firstName: string;
readonly lastName: string;
readonly email: string;
readonly phone: string;
readonly password: string;
}
And my userService is the following:
#Injectable()
export class UsersService implements IUsersService {
constructor(#InjectModel('User') private readonly userModel: PassportLocalModel<IUser>) {
}
async findAll(): Promise<IUser[]> {
return await this.userModel.find().exec();
}
I would like to add the mongoose-paginate functionality trough my IUser interface, so i can access it in the service via this.userModel.paginate.
I mention that I installed : "#types/mongoose-paginate": "^5.0.6" and "mongoose-paginate": "^5.0.3", and I can import PaginateModel from mongoose.
I guess the IUser interface should look something like this :
export interface IUser<T extends PassportLocalDocument > extends PaginateModel<T> {} but I am not sure, nor how to instantiate it when injecting into service.
Waiting ur responses guys, and Thanks! :D

Answer 1

This is a snippet for those who are using mongoose-paginate plugin with nestjs. You can also install #types/mongoose-paginate for getting the typings support
Code for adding the paginate plugin to the schema:
import { Schema } from 'mongoose';
import * as mongoosePaginate from 'mongoose-paginate';
export const MessageSchema = new Schema({
// Your schema definitions here
});
// Register plugin with the schema
MessageSchema.plugin(mongoosePaginate);
Now in the Message interface document
export interface Message extends Document {
// Your schema fields here
}
Now you can easily get the paginate method inside the service class like so
import { Injectable } from '#nestjs/common';
import { InjectModel } from '#nestjs/mongoose';
import { PaginateModel } from 'mongoose';
import { Message } from './interfaces/message.interface';
#Injectable()
export class MessagesService {
constructor(
// The 'PaginateModel' will provide the necessary pagination methods
#InjectModel('Message') private readonly messageModel: PaginateModel<Message>,
) {}
/**
* Find all messages in a channel
*
* #param {string} channelId
* #param {number} [page=1]
* #param {number} [limit=10]
* #returns
* #memberof MessagesService
*/
async findAllByChannelIdPaginated(channelId: string, page: number = 1, limit: number = 10) {
const options = {
populate: [
// Your foreign key fields to populate
],
page: Number(page),
limit: Number(limit),
};
// Get the data from database
return await this.messageModel.paginate({ channel: channelId }, options);
}
}

Answer 2

I approached the situation in a different matter. I've created 2 interfaces, 1 for registration/authentication and the other for data manipulation.
Once u import the PaginateModel you have to extend your interface with Document.
export interface IUser extends Document
Afterwards when you inject it into your service:
#InjectModel('User') private readonly userModel: PaginateModel<IUser>
And finally, in your service interface and service implementation, change the return type like this:
async findAll(yourParams: YourParamsDto): Promise<PaginateResult<IUser>>