How to implement pagination in nestjs with typeorm

summing up...

This middleware checks if you have the take and skip parameters in the URL, if it does, it converts from string to number, if you don't use the default values. 10 for take and 0 for skip.

take is the number of results per page and skip, from where it should start reading records.

With that, I set up to intercept the "product / paged" route just for the GET method.

With this I can retrieve these values in the controller and pass to TypeORM or an SQL query.

@Injectable()
export class PagerMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {
    req.query.take = +req.query.take || 10;
    req.query.skip = +req.query.skip || 0;
    next();
  }
}

and apply in module.

export class AdminFeatureApi implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(PagerMiddleware)
    .forRoutes({ path: 'product/paged', method: RequestMethod.GET })
  }
}

Controller

@Controller('product')
export class TrainingDomainController {
  constructor(private service: YourService) {}

  @Get('paged')
  get(@Query() { take, skip }) {
    return this.service.findAll(take, skip);
  }
}

and service

@Injectable()
export class YourService {
  constructor(
    @InjectRepository(YourEntity)
    private readonly repo: MongoRepository<YourEntity>
  ) {}

  async findAll(take: number = 10, skip: number = 0) {
    const [data, total] = await this.repo.findAndCount({ take, skip });
    return { data, total };
  }
}

ok?

You can also take a look at this package for NestJS and TypeORM:

https://github.com/nestjsx/nestjs-typeorm-paginate

You can find some nice example in this project. In short typeorm has a really nice method specific to this usecase findAndCount.

async findAll(query): Promise<Paginate> {
    const take = query.take || 10
    const skip = query.skip || 0
    const keyword = query.keyword || ''

    const [result, total] = await this.userRepository.findAndCount(
        {
            where: { name: Like('%' + keyword + '%') }, order: { name: "DESC" },
            take: take,
            skip: skip
        }
    );

    return {
        data: result,
        count: total
    }
}

Repository API you can find here. More documentation about Repository class can be found here.

i prefer using page instead of skip directly

• endpoint example : /users?page=4&take=3

  async findAll(query): Promise<Paginate> {
      const take = query.take || 10
      const page=query.page || 1;
      const skip= (page-1) * take ;
      const keyword = query.keyword || ''
  
      const [result, total] = await this.userRepository.findAndCount(
          {
              where: { name: Like('%' + keyword + '%') }, order: { name: "DESC" },
              take: take,
              skip: skip
          }
      );
  
      return {
          data: result,
          count: total
      }
  }
  

  2/. better way (handle the response) :

   async findAll(query): Promise<Paginate> {
       const take= query.take || 10
       const page=query.page || 1;
       const skip= (page-1) * take ;
       const keyword = query.keyword || ''
  
       const data = await this.userRepository.findAndCount(
           {
               where: { name: Like('%' + keyword + '%') }, order: { name: "DESC" },
               take: take,
               skip: skip
           }
       );
       return paginateResponse(data ,page,take)
  
   }
  

  export function paginateResponse(data,page,limit) {
    const [result, total]=data;
    const lastPage=Math.ceil(total/limit);
    const nextPage=page+1 >lastPage ? null :page+1;
    const prevPage=page-1 < 1 ? null :page-1;
    return {
      statusCode: 'success',
      data: [...result],
      count: total,
      currentPage: page,
      nextPage: nextPage,
      prevPage: prevPage,
      lastPage: lastPage,
    }
  }