refactor: introduce payment limits boundary and cache stub

Author: ndii-dev

src/limits/limits.module.ts

@@ -2,11 +2,12 @@ import { Module } from '@nestjs/common';
 import { LimitsService } from './limits.service';
 import { LimitsController } from './limits.controller';
 import { PrismaModule } from '../prisma/prisma.module';
+import { CacheService } from '../common/cache/cache.service';
 
 @Module({
   imports: [PrismaModule],
   controllers: [LimitsController],
-  providers: [LimitsService],
+  providers: [LimitsService, CacheService],
   exports: [LimitsService],
 })
 export class LimitsModule {}

src/limits/limits.service.spec.ts

@@ -2,10 +2,12 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { NotFoundException } from '@nestjs/common';
 import { LimitsService, LimitExceededException } from './limits.service';
 import { PrismaService } from '../prisma/prisma.service';
+import { CacheService } from '../common/cache/cache.service';
 
 describe('LimitsService', () => {
   let service: LimitsService;
   let prisma: any;
+  let cacheService: { get: jest.Mock; set: jest.Mock; delete: jest.Mock };
 
   const walletId = 'wallet-uuid-1';
 
@@ -21,8 +23,14 @@ describe('LimitsService', () => {
       },
     };
 
+    cacheService = { get: jest.fn(), set: jest.fn(), delete: jest.fn() };
+
     const module: TestingModule = await Test.createTestingModule({
-      providers: [LimitsService, { provide: PrismaService, useValue: prisma }],
+      providers: [
+        LimitsService,
+        { provide: PrismaService, useValue: prisma },
+        { provide: CacheService, useValue: cacheService },
+      ],
     }).compile();
 
     service = module.get<LimitsService>(LimitsService);
@@ -50,6 +58,17 @@ describe('LimitsService', () => {
       const result = await service.getLimits(walletId);
       expect(result).toEqual(limit);
     });
+
+    it('should use the cache layer for wallet limits', async () => {
+      const limit = { walletId, dailyLimit: 100, perTransactionLimit: 10 };
+      cacheService.get.mockReturnValue(limit);
+
+      const result = await service.getLimits(walletId);
+
+      expect(result).toEqual(limit);
+      expect(cacheService.get).toHaveBeenCalledWith(`limits:${walletId}`);
+      expect(prisma.walletLimit.findUnique).not.toHaveBeenCalled();
+    });
   });
 
   describe('checkLimits', () => {

src/limits/limits.service.ts

@@ -5,8 +5,8 @@ import {
   HttpStatus,
 } from '@nestjs/common';
 import { PrismaService } from '../prisma/prisma.service';
-import { CreateLimitDto, LimitPeriod } from './dto/create-limit.dto';
-import { UpdateLimitDto } from './dto/update-limit.dto';
+import { CacheService } from '../common/cache/cache.service';
+import { PaymentLimitsPort } from '../payments/ports/payment-limits.port';
 
 export const LIMIT_ERROR_CODES = {
   PER_TX_LIMIT_EXCEEDED: 'LIMIT_PER_TX_EXCEEDED',
@@ -26,19 +26,36 @@ export class LimitExceededException extends HttpException {
 }
 
 @Injectable()
-export class LimitsService {
-  constructor(private readonly prisma: PrismaService) {}
+export class LimitsService implements PaymentLimitsPort {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly cacheService: CacheService,
+  ) {}
 
   async setLimits(walletId: string, daily: number, perTx: number) {
-    return this.prisma.walletLimit.upsert({
+    const updated = await this.prisma.walletLimit.upsert({
       where: { walletId },
       update: { dailyLimit: daily, perTransactionLimit: perTx },
       create: { walletId, dailyLimit: daily, perTransactionLimit: perTx },
     });
+
+    this.cacheService.set(`limits:${walletId}`, updated);
+    return updated;
   }
 
   async getLimits(walletId: string) {
-    return this.prisma.walletLimit.findUnique({ where: { walletId } });
+    const cacheKey = `limits:${walletId}`;
+    const cached = this.cacheService.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const limits = await this.prisma.walletLimit.findUnique({ where: { walletId } });
+    if (limits) {
+      this.cacheService.set(cacheKey, limits);
+    }
+
+    return limits;
   }
 
   async checkLimits(walletId: string, amount: number): Promise<void> {
@@ -83,6 +100,9 @@ export class LimitsService {
     const existing = await this.getLimits(walletId);
     if (!existing)
       throw new NotFoundException(`No limits found for wallet ${walletId}`);
-    return this.prisma.walletLimit.delete({ where: { walletId } });
+
+    const deleted = await this.prisma.walletLimit.delete({ where: { walletId } });
+    this.cacheService.delete(`limits:${walletId}`);
+    return deleted;
   }
 }

src/payments/payments-limits.integration.spec.ts

@@ -6,6 +6,7 @@ import { WalletsService } from '../wallets/wallets.service';
 import { PrismaService } from '../prisma/prisma.service';
 import { PaymentStatus } from './entities/payment.entity';
 import { WalletStatus } from '../wallets/domain/wallet.model';
+import { PAYMENT_LIMITS_PORT } from './ports/payment-limits.port';
 
 describe('Payments and Limits Integration', () => {
   let paymentsService: PaymentsService;
@@ -38,6 +39,7 @@ describe('Payments and Limits Integration', () => {
         PaymentsService,
         LimitsService,
         { provide: PrismaService, useValue: mockPrisma },
+        { provide: PAYMENT_LIMITS_PORT, useExisting: LimitsService },
         { provide: WalletsService, useValue: mockWalletsService },
       ],
     }).compile();

src/payments/payments.module.ts

@@ -3,10 +3,15 @@ import { PaymentsService } from './payments.service';
 import { PaymentsController } from './payments.controller';
 import { LimitsModule } from '../limits/limits.module';
 import { WalletsModule } from '../wallets/wallets.module';
+import { LimitsService } from '../limits/limits.service';
+import { PAYMENT_LIMITS_PORT } from './ports/payment-limits.port';
 
 @Module({
   imports: [LimitsModule, WalletsModule],
   controllers: [PaymentsController],
-  providers: [PaymentsService],
+  providers: [
+    PaymentsService,
+    { provide: PAYMENT_LIMITS_PORT, useExisting: LimitsService },
+  ],
 })
 export class PaymentsModule {}

src/payments/payments.service.spec.ts

@@ -2,8 +2,8 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { BadRequestException, NotFoundException } from '@nestjs/common';
 import { PaymentsService } from './payments.service';
 import { PrismaService } from '../prisma/prisma.service';
-import { LimitsService } from '../limits/limits.service';
 import { WalletsService } from '../wallets/wallets.service';
+import { PAYMENT_LIMITS_PORT } from './ports/payment-limits.port';
 import { WalletStatus } from '../wallets/domain/wallet.model';
 import { PaymentStatus } from './entities/payment.entity';
 
@@ -26,7 +26,7 @@ const BASE_DTO = {
 describe('PaymentsService', () => {
   let service: PaymentsService;
   let prisma: any;
-  let limitsService: any;
+  let paymentLimitsPort: any;
   let walletsService: any;
 
   beforeEach(async () => {
@@ -39,14 +39,14 @@ describe('PaymentsService', () => {
         count: jest.fn(),
       },
     };
-    limitsService = { checkLimits: jest.fn() };
+    paymentLimitsPort = { checkLimits: jest.fn() };
     walletsService = { findWalletById: jest.fn() };
 
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         PaymentsService,
         { provide: PrismaService, useValue: prisma },
-        { provide: LimitsService, useValue: limitsService },
+        { provide: PAYMENT_LIMITS_PORT, useValue: paymentLimitsPort },
         { provide: WalletsService, useValue: walletsService },
       ],
     }).compile();
@@ -63,7 +63,7 @@ describe('PaymentsService', () => {
       walletsService.findWalletById
         .mockResolvedValueOnce(ACTIVE_WALLET)
         .mockResolvedValueOnce(RECEIVER_WALLET);
-      limitsService.checkLimits.mockResolvedValue(undefined);
+      paymentLimitsPort.checkLimits.mockResolvedValue(undefined);
       prisma.payment.create.mockResolvedValue({
         id: 1,
         ...BASE_DTO,
@@ -78,7 +78,7 @@ describe('PaymentsService', () => {
       expect(walletsService.findWalletById).toHaveBeenCalledWith(
         BASE_DTO.receiverWalletId,
       );
-      expect(limitsService.checkLimits).toHaveBeenCalledWith(
+      expect(paymentLimitsPort.checkLimits).toHaveBeenCalledWith(
         BASE_DTO.walletId,
         BASE_DTO.amount,
       );
@@ -151,7 +151,7 @@ describe('PaymentsService', () => {
       walletsService.findWalletById
         .mockResolvedValueOnce(ACTIVE_WALLET)
         .mockResolvedValueOnce(RECEIVER_WALLET);
-      limitsService.checkLimits.mockResolvedValue(undefined);
+      paymentLimitsPort.checkLimits.mockResolvedValue(undefined);
       prisma.payment.create.mockResolvedValue({
         id: 1,
         ...BASE_DTO,
@@ -160,7 +160,7 @@ describe('PaymentsService', () => {
 
       await service.create(BASE_DTO);
 
-      expect(limitsService.checkLimits).toHaveBeenCalledWith(
+      expect(paymentLimitsPort.checkLimits).toHaveBeenCalledWith(
         BASE_DTO.walletId,
         BASE_DTO.amount,
       );

src/payments/payments.service.ts

@@ -1,13 +1,17 @@
 import {
+  Inject,
   Injectable,
   NotFoundException,
   BadRequestException,
 } from '@nestjs/common';
 import { CreatePaymentDto } from './dto/create-payment.dto';
 import { UpdatePaymentDto } from './dto/update-payment.dto';
 import { PrismaService } from '../prisma/prisma.service';
-import { LimitsService } from '../limits/limits.service';
 import { WalletsService } from '../wallets/wallets.service';
+import {
+  PAYMENT_LIMITS_PORT,
+  PaymentLimitsPort,
+} from './ports/payment-limits.port';
 import { WalletStatus } from '../wallets/domain/wallet.model';
 import { PaymentStatus } from './entities/payment.entity';
 import { PaginationDto, PaginatedResponse } from '../common/dto/pagination.dto';
@@ -24,7 +28,8 @@ const ALLOWED_TRANSITIONS: Record<string, PaymentStatus[]> = {
 export class PaymentsService {
   constructor(
     private readonly prisma: PrismaService,
-    private readonly limitsService: LimitsService,
+    @Inject(PAYMENT_LIMITS_PORT)
+    private readonly paymentLimitsPort: PaymentLimitsPort,
     private readonly walletsService: WalletsService,
   ) {}
 
@@ -47,7 +52,7 @@ export class PaymentsService {
     }
 
     await this.walletsService.findWalletById(receiverWalletId);
-    await this.limitsService.checkLimits(walletId, amount);
+    await this.paymentLimitsPort.checkLimits(walletId, amount);
 
     return this.prisma.payment.create({
       data: {

src/payments/ports/payment-limits.port.ts

@@ -0,0 +1,8 @@
+import { Injectable, InjectionToken } from '@nestjs/common';
+
+export const PAYMENT_LIMITS_PORT = Symbol('PAYMENT_LIMITS_PORT') as InjectionToken;
+
+@Injectable()
+export abstract class PaymentLimitsPort {
+  abstract checkLimits(walletId: string, amount: number): Promise<void> | void;
+}