Merge pull request #436 from iheomadev/feature/340-transactions-pagination

feat(transactions): add pagination metadata response (#340)

Author: Jambox11

src/transactions/dto/paginated-transactions.dto.ts

@@ -0,0 +1,9 @@
+import { Transaction } from '../entities/transaction.entity';
+
+export class PaginatedTransactionsDto {
+  data: Transaction[];
+  total: number;
+  limit: number;
+  offset: number;
+  hasMore: boolean;
+}

src/transactions/transactions.controller.spec.ts

@@ -85,15 +85,16 @@ describe('TransactionsController', () => {
 
     it('should return the result from the service', async () => {
       const tx = { id: 'tx-1', status: TransactionStatus.PENDING };
-      mockTransactionsService.findByWallet.mockResolvedValue([tx]);
+      const paginated = { data: [tx], total: 1, limit: 20, offset: 0, hasMore: false };
+      mockTransactionsService.findByWallet.mockResolvedValue(paginated);
 
       const result = await controller.findByWallet(
         'wallet-1',
         undefined,
         undefined,
       );
 
-      expect(result).toEqual([tx]);
+      expect(result).toEqual(paginated);
     });
   });
 

src/transactions/transactions.service.spec.ts

@@ -44,6 +44,7 @@ const mockPrisma = {
     create: jest.fn(),
     findUnique: jest.fn(),
     findMany: jest.fn(),
+    count: jest.fn(),
     update: jest.fn(),
   },
 };
@@ -171,30 +172,59 @@ describe('TransactionsService', () => {
   });
 
   describe('findAll', () => {
-    it('returns all transactions without filters', async () => {
+    it('returns paginated transactions without filters', async () => {
       const txs = [makePrismaTransaction()];
       mockPrisma.transaction.findMany.mockResolvedValue(txs);
+      mockPrisma.transaction.count.mockResolvedValue(1);
 
       const result = await service.findAll();
 
       expect(mockPrisma.transaction.findMany).toHaveBeenCalledWith({
         where: {},
         orderBy: { createdAt: 'desc' },
-        take: undefined,
-        skip: undefined,
+        take: 20,
+        skip: 0,
       });
-      expect(result).toHaveLength(1);
+      expect(result.data).toHaveLength(1);
+      expect(result.total).toBe(1);
+      expect(result.limit).toBe(20);
+      expect(result.offset).toBe(0);
+      expect(result.hasMore).toBe(false);
+    });
+
+    it('uses provided limit and offset', async () => {
+      mockPrisma.transaction.findMany.mockResolvedValue([]);
+      mockPrisma.transaction.count.mockResolvedValue(10);
+
+      const result = await service.findAll({ limit: 5, offset: 5 });
+
+      expect(result.limit).toBe(5);
+      expect(result.offset).toBe(5);
+      expect(result.hasMore).toBe(false);
+    });
+
+    it('sets hasMore=true when more results exist', async () => {
+      const txs = [makePrismaTransaction()];
+      mockPrisma.transaction.findMany.mockResolvedValue(txs);
+      mockPrisma.transaction.count.mockResolvedValue(5);
+
+      const result = await service.findAll({ limit: 1, offset: 0 });
+
+      expect(result.hasMore).toBe(true);
     });
   });
 
   describe('findByWallet', () => {
-    it('returns transactions for a valid wallet', async () => {
+    it('returns paginated transactions for a valid wallet', async () => {
       mockPrisma.wallet.findUnique.mockResolvedValue({ id: 'wallet-1' });
       mockPrisma.transaction.findMany.mockResolvedValue([makePrismaTransaction()]);
+      mockPrisma.transaction.count.mockResolvedValue(1);
 
       const result = await service.findByWallet('wallet-1');
 
-      expect(result).toHaveLength(1);
+      expect(result.data).toHaveLength(1);
+      expect(result.total).toBe(1);
+      expect(result.hasMore).toBe(false);
     });
 
     it('throws NotFoundException when wallet does not exist', async () => {

src/transactions/transactions.service.ts

@@ -3,7 +3,6 @@ import {
   Logger,
   NotFoundException,
   BadRequestException,
-  Optional,
 } from '@nestjs/common';
 import { PrismaService } from '../prisma/prisma.service';
 import { BalanceIndexerService } from '../balance-indexer/balance-indexer.service';
@@ -20,6 +19,7 @@ import {
   StellarNetworkReferences,
 } from './domain/transaction.model';
 import { Transaction as TransactionEntity } from './entities/transaction.entity';
+import { PaginatedTransactionsDto } from './dto/paginated-transactions.dto';
 import { InsufficientBalanceException } from './domain/insufficient-balance.exception';
 import { WebhookEventEmitterService } from '../webhooks/webhook-event-emitter.service';
 import { CacheService } from '../common/cache/cache.service';
@@ -140,15 +140,15 @@ export class TransactionsService {
   }
 
   /**
-   * Find all transactions with optional filters
+   * Find all transactions with optional filters, returns paginated response
    */
   async findAll(filters?: {
     senderWalletId?: string;
     receiverWalletId?: string;
     status?: TransactionStatus;
     limit?: number;
     offset?: number;
-  }): Promise<TransactionEntity[]> {
+  }): Promise<PaginatedTransactionsDto> {
     const where: any = {};
 
     if (filters?.senderWalletId) {
@@ -163,14 +163,26 @@ export class TransactionsService {
       where.status = filters.status;
     }
 
-    const transactions = await this.prisma.transaction.findMany({
-      where,
-      orderBy: { createdAt: 'desc' },
-      take: filters?.limit,
-      skip: filters?.offset,
-    });
+    const limit = filters?.limit ?? 20;
+    const offset = filters?.offset ?? 0;
+
+    const [transactions, total] = await Promise.all([
+      this.prisma.transaction.findMany({
+        where,
+        orderBy: { createdAt: 'desc' },
+        take: limit,
+        skip: offset,
+      }),
+      this.prisma.transaction.count({ where }),
+    ]);
 
-    return transactions.map((t) => this.mapPrismaToEntity(t));
+    return {
+      data: transactions.map((t) => this.mapPrismaToEntity(t)),
+      total,
+      limit,
+      offset,
+      hasMore: offset + transactions.length < total,
+    };
   }
 
   /**
@@ -294,12 +306,12 @@ export class TransactionsService {
   }
 
   /**
-   * Find transactions by wallet ID with pagination
+   * Find transactions by wallet ID with pagination metadata
    */
   async findByWallet(
     walletId: string,
     pagination?: { limit?: number; offset?: number },
-  ): Promise<TransactionEntity[]> {
+  ): Promise<PaginatedTransactionsDto> {
     const wallet = await this.prisma.wallet.findUnique({
       where: { id: walletId },
     });
@@ -308,16 +320,29 @@ export class TransactionsService {
       throw new NotFoundException(`Wallet ${walletId} not found`);
     }
 
-    const transactions = await this.prisma.transaction.findMany({
-      where: {
-        OR: [{ senderWalletId: walletId }, { receiverWalletId: walletId }],
-      },
-      orderBy: { createdAt: 'desc' },
-      take: pagination?.limit,
-      skip: pagination?.offset,
-    });
+    const limit = pagination?.limit ?? 20;
+    const offset = pagination?.offset ?? 0;
+    const where = {
+      OR: [{ senderWalletId: walletId }, { receiverWalletId: walletId }],
+    };
+
+    const [transactions, total] = await Promise.all([
+      this.prisma.transaction.findMany({
+        where,
+        orderBy: { createdAt: 'desc' },
+        take: limit,
+        skip: offset,
+      }),
+      this.prisma.transaction.count({ where }),
+    ]);
 
-    return transactions.map((t) => this.mapPrismaToEntity(t));
+    return {
+      data: transactions.map((t) => this.mapPrismaToEntity(t)),
+      total,
+      limit,
+      offset,
+      hasMore: offset + transactions.length < total,
+    };
   }
 
   /**