Merge pull request #1300 from Oliver2929/feat/faq-pagination

feat: Implement Pagination for finding all Faqs endpoint

.gitignore

@@ -392,8 +392,8 @@ Temporary Items
 .apdisk
 
 # Local
-dist
-/.env
+dist/
+.env
 /.env.*
 *._local.ts
 

src/modules/faq/faq.service.ts

@@ -36,23 +36,64 @@ export class FaqService {
     return this.faqRepository.save(faq);
   }
 
-  async findAllFaq(language?: string) {
-    const faqs = await this.faqRepository.find();
-
-    const translatedFaqs = await Promise.all(
-      faqs.map(async faq => {
-        faq.question = await this.translateContent(faq.question, language);
-        faq.answer = await this.translateContent(faq.answer, language);
-        faq.category = await this.translateContent(faq.category, language);
-        return faq;
-      })
-    );
+  async findAllFaq(language?: string, page: number = 1, pageSize: number = 10) {
+    try {
+      if (page <= 0 || pageSize <= 0) {
+        return {
+          status: 'error',
+          status_code: 400,
+          message: 'Invalid page or pageSize value.',
+          data: {},
+        };
+      }
+
+      // Calculate offset and limit
+      const offset = (page - 1) * pageSize;
+      const limit = pageSize;
+
+      // Fetch all FAQs from the repository
+      const faqs = await this.faqRepository.find({
+        skip: offset,
+        take: limit,
+      });
 
-    return {
-      message: 'Faq fetched successfully',
-      status_code: 200,
-      data: translatedFaqs,
-    };
+      // Total count of FAQs for pagination metadata
+      const total = await this.faqRepository.count();
+
+      const translatedFaqs = await Promise.all(
+        faqs.map(async faq => {
+          faq.question = await this.translateContent(faq.question, language);
+          faq.answer = await this.translateContent(faq.answer, language);
+          faq.category = await this.translateContent(faq.category, language);
+          return faq;
+        })
+      );
+
+      // Calculate total pages
+      const totalPages = Math.ceil(total / pageSize);
+
+      // Return paginated response
+      return {
+        status: 'success', // Added status field
+        status_code: 200,
+        message: 'Faq fetched successfully',
+        data: {
+          // Ensure data is always included
+          faqs: translatedFaqs,
+          total,
+          page,
+          pageSize,
+          totalPages,
+        },
+      };
+    } catch (error) {
+      return {
+        status: 'error',
+        status_code: 500,
+        message: 'An error occurred while fetching the FAQs.',
+        data: {},
+      };
+    }
   }
 
   async updateFaq(id: string, updateFaqDto: UpdateFaqDto, language?: string) {

src/modules/faq/test/faq.service.spec.ts

@@ -21,6 +21,7 @@ describe('FaqService', () => {
     findOne: jest.fn(),
     save: jest.fn(),
     delete: jest.fn(),
+    count: jest.fn(),
   };
 
   beforeEach(async () => {
@@ -47,21 +48,35 @@ describe('FaqService', () => {
   });
 
   describe('findAll', () => {
-    it('should return an array of FAQs', async () => {
+    it('should return a paginated list of FAQs', async () => {
       const mockFaqs = [
         { id: '1', question: 'Q1', answer: 'A1', category: 'C1' },
         { id: '2', question: 'Q2', answer: 'A2', category: 'C2' },
       ];
-      mockRepository.find.mockResolvedValue(mockFaqs);
 
-      const result = await service.findAllFaq();
+      const page = 1;
+      const pageSize = 10;
+      const totalFaqs = 20; // Total FAQs in the database
 
-      expect(result).toEqual({
-        data: mockFaqs,
-        message: 'Faq fetched successfully',
-        status_code: 200,
+      mockRepository.find.mockResolvedValue(mockFaqs);
+      mockRepository.count.mockResolvedValue(totalFaqs);
+
+      const result = await service.findAllFaq('en', page, pageSize);
+
+      expect(result.status).toBe('success');
+      expect(result.status_code).toBe(200);
+      expect(result.message).toBe('Faq fetched successfully');
+      expect(result.data.faqs).toEqual(mockFaqs);
+      expect(result.data.total).toBe(totalFaqs);
+      expect(result.data.page).toBe(page);
+      expect(result.data.pageSize).toBe(pageSize);
+      expect(result.data.totalPages).toBe(Math.ceil(totalFaqs / pageSize));
+
+      expect(mockRepository.find).toHaveBeenCalledWith({
+        skip: (page - 1) * pageSize,
+        take: pageSize,
       });
-      expect(mockRepository.find).toHaveBeenCalled();
+      expect(mockRepository.count).toHaveBeenCalled();
     });
   });