Merge branch 'feat-implement-pagination-on-findAllTeamMembers-endpoin…

…t' of https://github.com/akinwalexander/hng_boilerplate_nestjs into feat-implement-pagination-on-findAllTeamMembers-endpoint

.gitignore

@@ -403,10 +403,22 @@ dist
 # User specific ignores 
 todo.txt
 .vscode/
+
+# Docker compose
+docker-compose.yml
+data/
+
+# Docker compose
+docker-compose.yml
+data/
+
 data/
 docker-compose.yml
 package-lock.json
 .dev.env
-data
 
-/data/db/base
+
+package-lock.json
+docker-compose.yml
+data/
+.dev.env

.vscode/settings.json

@@ -33,6 +33,6 @@
     "source.fixAll": "explicit"
   },
   "[typescript]": {
-    "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+    "editor.defaultFormatter": "vscode.typescript-language-features"
   }
 }

src/modules/auth/auth.service.ts

@@ -62,7 +62,7 @@ export default class AuthenticationService {
 
     const newOrganisation = await this.organisationService.create(newOrganisationPayload, user.id);
 
-    const userOranisations = await this.organisationService.getAllUserOrganisations(user.id);
+    const userOranisations = await this.organisationService.getAllUserOrganisations(user.id, 1, 10);
     const isSuperAdmin = userOranisations.map(instance => instance.user_role).includes('super-admin');
     const token = (await this.otpService.createOtp(user.id)).token;
 
@@ -174,7 +174,7 @@ export default class AuthenticationService {
     if (!isMatch) {
       throw new CustomHttpException(SYS_MSG.INVALID_CREDENTIALS, HttpStatus.UNAUTHORIZED);
     }
-    const userOranisations = await this.organisationService.getAllUserOrganisations(user.id);
+    const userOranisations = await this.organisationService.getAllUserOrganisations(user.id, 1, 10);
     const access_token = this.jwtService.sign({ id: user.id, sub: user.id });
     const isSuperAdmin = userOranisations.map(instance => instance.user_role).includes('super-admin');
     const responsePayload = {
@@ -328,7 +328,7 @@ export default class AuthenticationService {
       return await this.createUserGoogle(userCreationPayload);
     }
 
-    const userOranisations = await this.organisationService.getAllUserOrganisations(userExists.id);
+    const userOranisations = await this.organisationService.getAllUserOrganisations(userExists.id, 1, 10);
     const isSuperAdmin = userOranisations.map(instance => instance.user_role).includes('super-admin');
     const accessToken = this.jwtService.sign({
       sub: userExists.id,
@@ -376,7 +376,7 @@ export default class AuthenticationService {
 
     await this.organisationService.create(newOrganisationPaload, newUser.id);
 
-    const userOranisations = await this.organisationService.getAllUserOrganisations(newUser.id);
+    const userOranisations = await this.organisationService.getAllUserOrganisations(newUser.id, 1, 10);
     const isSuperAdmin = userOranisations.map(instance => instance.user_role).includes('super-admin');
 
     const accessToken = this.jwtService.sign({

src/modules/blogs/blogs.controller.ts

@@ -16,6 +16,7 @@ import {
 import { ApiBearerAuth, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { BlogService } from './blogs.service';
 import { SuperAdminGuard } from '@guards/super-admin.guard';
+import { AuthGuard } from '@guards/auth.guard';
 import { BlogResponseDto } from './dtos/blog-response.dto';
 import { CreateBlogDto } from './dtos/create-blog.dto';
 import { UpdateBlogResponseDto } from './dtos/update-blog-response.dto';
@@ -30,7 +31,7 @@ export class BlogController {
 
   @ApiBearerAuth()
   @Post()
-  @UseGuards(SuperAdminGuard)
+  @UseGuards(AuthGuard)
   @ApiOperation({ summary: 'Create a new blog' })
   @ApiResponse({ status: 201, description: 'The blog has been successfully created.', type: BlogResponseDto })
   @ApiResponse({ status: 403, description: 'Forbidden.' })

src/modules/newsletter-subscription/dto/unsubscribe-newsletter.dto.ts

@@ -0,0 +1,8 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEmail } from 'class-validator';
+
+export class UnsubscribeNewsletterDto {
+  @ApiProperty({ description: 'Email of the user to unsubscribe' })
+  @IsEmail()
+  email: string;
+}

src/modules/newsletter-subscription/entities/newsletter-subscription.entity.ts

@@ -8,4 +8,7 @@ export class NewsletterSubscription extends AbstractBaseEntity {
 
   @DeleteDateColumn()
   deletedAt: Date;
+
+  @Column({ default: false })
+  isUnsubscribed: boolean;
 }

src/modules/newsletter-subscription/newsletter-subscription.controller.ts

@@ -5,6 +5,7 @@ import { skipAuth } from '@shared/helpers/skipAuth';
 import { ApiBearerAuth, ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { NewsletterSubscriptionResponseDto } from './dto/newsletter-subscription.response.dto';
 import { SuperAdminGuard } from '@guards/super-admin.guard';
+import { UnsubscribeNewsletterDto } from './dto/unsubscribe-newsletter.dto';
 
 @ApiTags('Newsletter Subscription')
 @Controller('newsletter-subscription')
@@ -115,4 +116,14 @@ export class NewsletterSubscriptionController {
   restore(@Param('id') id: string) {
     return this.newsletterSubscriptionService.restore(id);
   }
+
+  @Post('unsubscribe')
+  @skipAuth()
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Unsubscribe from the newsletter' })
+  @ApiResponse({ status: 200, description: 'User has been unsubscribed successfully.' })
+  @ApiResponse({ status: 404, description: 'Email not found' })
+  unsubscribe(@Body() unsubscribeDto: UnsubscribeNewsletterDto) {
+    return this.newsletterSubscriptionService.unsubscribe(unsubscribeDto.email);
+  }
 }

src/modules/newsletter-subscription/newsletter-subscription.service.ts

@@ -72,4 +72,17 @@ export class NewsletterSubscriptionService {
       email: newsletterSubscription.email,
     };
   }
+
+  async unsubscribe(email: string) {
+    const subscription = await this.newsletterSubscriptionRepository.findOne({ where: { email } });
+
+    if (!subscription) {
+      throw new NotFoundException(`Email ${email} not found in the subscription list`);
+    }
+
+    subscription.isUnsubscribed = true;
+    await this.newsletterSubscriptionRepository.save(subscription);
+
+    return { message: `Email ${email} has been unsubscribed successfully` };
+  }
 }

src/modules/newsletter-subscription/tests/newsletter-subscription.service.spec.ts

@@ -146,4 +146,47 @@ describe('NewsletterService', () => {
       await expect(service.restore(id)).rejects.toThrow(NotFoundException);
     });
   });
+
+  describe('unsubscribe', () => {
+    it('should successfully unsubscribe a user', async () => {
+      const email = '[email protected]';
+      const mockSubscription = { id: '1', email, isUnsubscribed: false } as NewsletterSubscription;
+
+      // Mock `findOne` to return a subscribed user
+      jest.spyOn(repository, 'findOne').mockResolvedValue(mockSubscription);
+      // Mock `save` to return updated object
+      jest.spyOn(repository, 'save').mockImplementation(
+        async sub =>
+          ({
+            ...sub,
+            isUnsubscribed: true,
+            email: sub.email,
+            deletedAt: sub.deletedAt || new Date(),
+            id: sub.id,
+            created_at: sub.created_at || new Date(),
+            updated_at: new Date(),
+          }) as NewsletterSubscription
+      );
+
+      const result = await service.unsubscribe(email);
+      expect(result).toEqual({ message: `Email ${email} has been unsubscribed successfully` });
+
+      // Ensure `isUnsubscribed` was updated
+      expect(repository.save).toHaveBeenCalledWith(expect.objectContaining({ isUnsubscribed: true }));
+    });
+
+    it('should throw NotFoundException if email is not found', async () => {
+      const email = '[email protected]';
+
+      // Mock `findOne` to return null
+      jest.spyOn(repository, 'findOne').mockResolvedValue(null);
+
+      // Expecting an error
+      await expect(service.unsubscribe(email)).rejects.toThrow(
+        new NotFoundException(`Email ${email} not found in the subscription list`)
+      );
+
+      expect(repository.findOne).toHaveBeenCalledWith({ where: { email } });
+    });
+  });
 });

src/modules/notifications/notifications.controller.ts

@@ -11,6 +11,7 @@ import {
   ApiInternalServerErrorResponse,
   ApiOkResponse,
   ApiOperation,
+  ApiQuery,
   ApiResponse,
   ApiTags,
   ApiUnauthorizedResponse,
@@ -45,6 +46,8 @@ export class NotificationsController {
   }
 
   @Get('/all')
+  @ApiQuery({ name: 'page', required: false, type: Number, description: 'Page number for pagination' })
+  @ApiQuery({ name: 'limit', required: false, type: Number, description: 'Number of notifications per page' })
   @ApiResponse({
     status: 200,
     description: 'Notifications retrieved successfully',
@@ -53,9 +56,13 @@ export class NotificationsController {
   @ApiInternalServerErrorResponse({
     description: 'Failed to retrieve notifications.',
   })
-  async getNotifications(@Req() req: { user: UserPayload }) {
+  async getNotifications(
+    @Req() req: { user: UserPayload },
+    @Query('page') page: number = 1,
+    @Query('limit') limit: number = 10
+  ) {
     const userId = req.user.id;
-    const notifications = await this.notificationsService.getNotificationsForUser(userId);
+    const notifications = await this.notificationsService.getNotificationsForUser(userId, page, limit);
 
     return {
       status: 'success',
@@ -70,6 +77,8 @@ export class NotificationsController {
           message,
           created_at,
         })),
+        current_page: page,
+        total_pages: Math.ceil(notifications.totalNotificationCount / limit),
       },
     };
   }

src/modules/notifications/notifications.service.ts

@@ -61,20 +61,24 @@ export class NotificationsService {
     };
   }
 
-  async getNotificationsForUser(userId: string) {
+  async getNotificationsForUser(userId: string, page: number, limit: number) {
     try {
       const user = await this.userRepository.findOne({ where: { id: userId } });
       if (!user) {
         throw new NotFoundException('User not found');
       }
 
-      const notifications = await this.notificationRepository.find({
+      const [notifications, totalNotificationCount] = await this.notificationRepository.findAndCount({
         where: { user: { id: userId } },
         order: { created_at: 'DESC' },
+        skip: (page - 1) * limit,
+        take: limit,
+      });
+
+      const totalUnreadNotificationCount = await this.notificationRepository.count({
+        where: { user: { id: userId }, is_read: false },
       });
 
-      const totalNotificationCount = notifications.length;
-      const totalUnreadNotificationCount = notifications.filter(notification => !notification.is_read).length;
       return {
         totalNotificationCount,
         totalUnreadNotificationCount,

src/modules/organisations/organisations.controller.ts

@@ -78,9 +78,13 @@ export class OrganisationsController {
   @ApiResponse({ status: 200, description: 'Organisations retrieved successfully', type: UserOrganizationResponseDto })
   @ApiResponse({ status: 400, description: 'Bad request', type: UserOrganizationErrorResponseDto })
   @Get('/')
-  async getUserOrganisations(@Req() req) {
+  async getUserOrganisations(
+    @Req() req,
+    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
+    @Query('page_size', new DefaultValuePipe(10), ParseIntPipe) page_size: number
+  ) {
     const { sub } = req.user;
-    return this.organisationsService.getUserOrganisations(sub);
+    return this.organisationsService.getUserOrganisations(sub, page, page_size);
   }
 
   @UseGuards(OwnershipGuard)

src/modules/organisations/organisations.service.ts

@@ -139,25 +139,37 @@ export class OrganisationsService {
     };
   }
 
-  async getUserOrganisations(userId: string) {
-    const organisations = await this.getAllUserOrganisations(userId);
+  async getUserOrganisations(userId: string, page: number, page_size: number) {
+    const organisations = await this.getAllUserOrganisations(userId, page, page_size);
+    const total_count = await this.organisationUserRole.count({ where: { userId } });
+
     return {
       status_code: HttpStatus.OK,
       message: 'Organisations retrieved successfully',
-      data: organisations,
+      data: {
+        organisations,
+        total_count,
+        current_page: page,
+        page_size,
+      },
     };
   }
 
-  async getAllUserOrganisations(userId: string) {
+  async getAllUserOrganisations(userId: string, page: number, page_size: number) {
     const user = await this.userRepository.findOne({ where: { id: userId } });
 
     if (!user) {
       throw new CustomHttpException('Invalid Request', HttpStatus.BAD_REQUEST);
     }
+
+    const skip = (page - 1) * page_size;
+
     const userOrganisations = (
       await this.organisationUserRole.find({
         where: { userId },
         relations: ['organisation', 'organisation.owner', 'role'],
+        skip,
+        take: page_size,
       })
     ).map(instance => ({
       organisation_id: instance?.organisation?.id || '',