Advanced Pagination and Filtering System

Author: ustaxs

src/common/pagination/index.ts

@@ -0,0 +1,3 @@
+export * from './page.dto';
+export * from './page-meta.dto';
+export * from './page-options.dto';

src/common/pagination/page-meta.dto.ts

@@ -0,0 +1,29 @@
+import { PageOptionsDto } from './page-options.dto';
+
+export class PageMetaDto {
+  readonly page: number;
+  readonly limit: number;
+  readonly itemCount: number;
+  readonly pageCount: number;
+  readonly hasPreviousPage: boolean;
+  readonly hasNextPage: boolean;
+  readonly nextCursor?: string;
+
+  constructor({
+    pageOptionsDto,
+    itemCount,
+    nextCursor,
+  }: {
+    pageOptionsDto: PageOptionsDto;
+    itemCount: number;
+    nextCursor?: string;
+  }) {
+    this.page = pageOptionsDto.page;
+    this.limit = pageOptionsDto.limit;
+    this.itemCount = itemCount;
+    this.pageCount = Math.ceil(this.itemCount / this.limit);
+    this.hasPreviousPage = this.page > 1;
+    this.hasNextPage = this.page < this.pageCount;
+    this.nextCursor = nextCursor;
+  }
+}

src/common/pagination/page-options.dto.ts

@@ -0,0 +1,29 @@
+import { IsInt, IsOptional, IsString, Max, Min } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class PageOptionsDto {
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @IsOptional()
+  readonly page?: number = 1;
+
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  @IsOptional()
+  readonly limit?: number = 10;
+
+  @IsString()
+  @IsOptional()
+  readonly sort?: string;
+
+  @IsString()
+  @IsOptional()
+  readonly filter?: string;
+
+  @IsString()
+  @IsOptional()
+  readonly cursor?: string;
+}

src/common/pagination/page.dto.ts

@@ -0,0 +1,14 @@
+import { IsArray } from 'class-validator';
+import { PageMetaDto } from './page-meta.dto';
+
+export class PageDto<T> {
+  @IsArray()
+  readonly data: T[];
+
+  readonly meta: PageMetaDto;
+
+  constructor(data: T[], meta: PageMetaDto) {
+    this.data = data;
+    this.meta = meta;
+  }
+}

src/users/users.controller.ts

@@ -1,9 +1,21 @@
-import { Controller, Get, Post, Body, Patch, Param, Delete, UseInterceptors, UploadedFile } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+  UseInterceptors,
+  UploadedFile,
+  Query,
+} from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
 import { fileFilter } from '../common/validators/file-upload.validator';
 import { UsersService } from './users.service';
 import { CreateUserDto } from './dto/create-user.dto';
 import { UpdateUserDto } from './dto/update-user.dto';
+import { PageOptionsDto } from '../common/pagination';
 
 type UploadedFile = {
   originalname: string;
@@ -19,8 +31,8 @@ export class UsersController {
   }
 
   @Get()
-  findAll() {
-    return this.usersService.findAll();
+  findAll(@Query() pageOptionsDto: PageOptionsDto) {
+    return this.usersService.findAll(pageOptionsDto);
   }
 
   @Get(':id')
@@ -40,12 +52,20 @@ export class UsersController {
 
   // Example: File upload with validation (avatar upload)
   @Post('avatar')
-  @UseInterceptors(FileInterceptor('file', {
-    fileFilter: fileFilter(['.png', '.jpg', '.jpeg'], ['image/png', 'image/jpeg']),
-    limits: { fileSize: 2 * 1024 * 1024 }, // 2MB
-  }))
+  @UseInterceptors(
+    FileInterceptor('file', {
+      fileFilter: fileFilter(
+        ['.png', '.jpg', '.jpeg'],
+        ['image/png', 'image/jpeg'],
+      ),
+      limits: { fileSize: 2 * 1024 * 1024 }, // 2MB
+    }),
+  )
   uploadAvatar(@UploadedFile() file: UploadedFile) {
     // Only validation logic shown; file storage logic can be added as needed
-    return { message: 'Avatar uploaded successfully', filename: file.originalname };
+    return {
+      message: 'Avatar uploaded successfully',
+      filename: file.originalname,
+    };
   }
 }

src/users/users.module.ts

@@ -1,8 +1,11 @@
 import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
 import { UsersService } from './users.service';
 import { UsersController } from './users.controller';
+import { User } from './entities/user.entity';
 
 @Module({
+  imports: [TypeOrmModule.forFeature([User])],
   controllers: [UsersController],
   providers: [UsersService],
 })

src/users/users.service.ts

@@ -1,26 +1,72 @@
 import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { PageOptionsDto, PageDto, PageMetaDto } from '../../common/pagination';
 import { CreateUserDto } from './dto/create-user.dto';
 import { UpdateUserDto } from './dto/update-user.dto';
+import { User } from './entities/user.entity';
 
 @Injectable()
 export class UsersService {
+  constructor(
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>,
+  ) {}
+
   create(createUserDto: CreateUserDto) {
-    return 'This action adds a new user';
+    const user = this.userRepository.create(createUserDto);
+    return this.userRepository.save(user);
   }
 
-  findAll() {
-    return `This action returns all users`;
+  async findAll(pageOptionsDto: PageOptionsDto): Promise<PageDto<User>> {
+    const queryBuilder = this.userRepository.createQueryBuilder('user');
+
+    if (pageOptionsDto.filter) {
+      queryBuilder.where('user.username LIKE :filter', {
+        filter: `%${pageOptionsDto.filter}%`,
+      });
+    }
+
+    if (pageOptionsDto.cursor) {
+      const cursorDate = new Date(pageOptionsDto.cursor);
+      queryBuilder.andWhere('user.createdAt > :cursor', { cursor: cursorDate });
+    }
+
+    if (pageOptionsDto.sort) {
+      const [field, order] = pageOptionsDto.sort.split(':');
+      queryBuilder.orderBy(`user.${field}`, order as 'ASC' | 'DESC');
+    } else {
+      queryBuilder.orderBy('user.createdAt', 'DESC');
+    }
+
+    queryBuilder.take(pageOptionsDto.limit);
+
+    const itemCount = await queryBuilder.getCount();
+    const { entities } = await queryBuilder.getRawAndEntities();
+
+    const nextCursor =
+      entities.length > 0
+        ? entities[entities.length - 1].createdAt.toISOString()
+        : null;
+    const pageMetaDto = new PageMetaDto({
+      itemCount,
+      pageOptionsDto,
+      nextCursor,
+    });
+
+    return new PageDto(entities, pageMetaDto);
   }
 
   findOne(id: string) {
-    return `This action returns a user with id #${id}`;
+    return this.userRepository.findOne({ where: { id } });
   }
 
-  update(id: string, updateUserDto: UpdateUserDto) {
-    return `This action updates a user with id #${id}`;
+  async update(id: string, updateUserDto: UpdateUserDto) {
+    await this.userRepository.update(id, updateUserDto);
+    return this.findOne(id);
   }
 
   remove(id: string) {
-    return `This action removes a user with id #${id}`;
+    return this.userRepository.softDelete(id);
   }
 }