Merge pull request #277 from soter-fashion/feat/226-wallet-limits

feat: replace LegacyUser limits with Wallet limits (#226)

Author: Jambox11

prisma/migrations/1_add_wallet_limit/migration.sql

@@ -0,0 +1,20 @@
+-- CreateTable
+CREATE TABLE "WalletLimit" (
+    "id" TEXT NOT NULL,
+    "walletId" TEXT NOT NULL,
+    "dailyLimit" DOUBLE PRECISION NOT NULL,
+    "perTransactionLimit" DOUBLE PRECISION NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "WalletLimit_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "WalletLimit_walletId_key" ON "WalletLimit"("walletId");
+
+-- CreateIndex
+CREATE INDEX "WalletLimit_walletId_idx" ON "WalletLimit"("walletId");
+
+-- AddForeignKey
+ALTER TABLE "WalletLimit" ADD CONSTRAINT "WalletLimit_walletId_fkey" FOREIGN KEY ("walletId") REFERENCES "Wallet"("id") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/schema.prisma

@@ -56,6 +56,19 @@ model UserLimit {
   user                LegacyUser @relation(fields: [userId], references: [id])
 }
 
+/// Spending limits scoped to a Wallet (replaces legacy UserLimit)
+model WalletLimit {
+  id                  String  @id @default(uuid())
+  walletId            String  @unique
+  wallet              Wallet  @relation(fields: [walletId], references: [id], onDelete: Cascade)
+  dailyLimit          Float
+  perTransactionLimit Float
+  createdAt           DateTime @default(now())
+  updatedAt           DateTime @updatedAt
+
+  @@index([walletId])
+}
+
 /// Mainnet/testnet separation for all wallets.
 enum WalletNetwork {
   MAINNET
@@ -159,6 +172,9 @@ model Wallet {
   recoveryRequests RecoveryRequest[]
   balances         WalletBalance[]
   
+  /// Spending limits for this wallet
+  walletLimit          WalletLimit?
+
   /// Transactions sent from this wallet
   sentTransactions     Transaction[] @relation("SentTransactions")
   

src/limits/limits.controller.spec.ts

@@ -4,22 +4,20 @@ import { LimitsService } from './limits.service';
 
 describe('LimitsController', () => {
   let controller: LimitsController;
+  let limitsService: any;
+
+  const walletId = 'wallet-uuid-1';
 
   beforeEach(async () => {
+    limitsService = {
+      setLimits: jest.fn(),
+      getLimits: jest.fn(),
+      removeLimits: jest.fn(),
+    };
+
     const module: TestingModule = await Test.createTestingModule({
       controllers: [LimitsController],
-      providers: [
-        {
-          provide: LimitsService,
-          useValue: {
-            create: jest.fn(),
-            findAll: jest.fn(),
-            findOne: jest.fn(),
-            update: jest.fn(),
-            remove: jest.fn(),
-          },
-        },
-      ],
+      providers: [{ provide: LimitsService, useValue: limitsService }],
     }).compile();
 
     controller = module.get<LimitsController>(LimitsController);
@@ -28,4 +26,20 @@ describe('LimitsController', () => {
   it('should be defined', () => {
     expect(controller).toBeDefined();
   });
+
+  it('setLimits should delegate to service', async () => {
+    const dto = { dailyLimit: 500, perTransactionLimit: 100 };
+    await controller.setLimits(walletId, dto as any);
+    expect(limitsService.setLimits).toHaveBeenCalledWith(walletId, 500, 100);
+  });
+
+  it('getLimits should delegate to service', async () => {
+    await controller.getLimits(walletId);
+    expect(limitsService.getLimits).toHaveBeenCalledWith(walletId);
+  });
+
+  it('removeLimits should delegate to service', async () => {
+    await controller.removeLimits(walletId);
+    expect(limitsService.removeLimits).toHaveBeenCalledWith(walletId);
+  });
 });

src/limits/limits.controller.ts

@@ -3,40 +3,44 @@ import {
   Get,
   Post,
   Body,
-  Patch,
   Param,
   Delete,
+  HttpCode,
+  HttpStatus,
 } from '@nestjs/common';
 import { LimitsService } from './limits.service';
-import { CreateLimitDto } from './dto/create-limit.dto';
-import { UpdateLimitDto } from './dto/update-limit.dto';
+import { IsNumber, IsPositive } from 'class-validator';
 
-@Controller('limits')
+class SetLimitsDto {
+  @IsNumber()
+  @IsPositive()
+  dailyLimit: number;
+
+  @IsNumber()
+  @IsPositive()
+  perTransactionLimit: number;
+}
+
+@Controller('wallets/:walletId/limits')
 export class LimitsController {
   constructor(private readonly limitsService: LimitsService) {}
 
   @Post()
-  create(@Body() createLimitDto: CreateLimitDto) {
-    return this.limitsService.create(createLimitDto);
+  setLimits(
+    @Param('walletId') walletId: string,
+    @Body() dto: SetLimitsDto,
+  ) {
+    return this.limitsService.setLimits(walletId, dto.dailyLimit, dto.perTransactionLimit);
   }
 
   @Get()
-  findAll() {
-    return this.limitsService.findAll();
-  }
-
-  @Get(':id')
-  findOne(@Param('id') id: string) {
-    return this.limitsService.findOne(+id);
-  }
-
-  @Patch(':id')
-  update(@Param('id') id: string, @Body() updateLimitDto: UpdateLimitDto) {
-    return this.limitsService.update(+id, updateLimitDto);
+  getLimits(@Param('walletId') walletId: string) {
+    return this.limitsService.getLimits(walletId);
   }
 
-  @Delete(':id')
-  remove(@Param('id') id: string) {
-    return this.limitsService.remove(+id);
+  @Delete()
+  @HttpCode(HttpStatus.NO_CONTENT)
+  removeLimits(@Param('walletId') walletId: string) {
+    return this.limitsService.removeLimits(walletId);
   }
 }

src/limits/limits.service.spec.ts

@@ -1,19 +1,23 @@
 import { Test, TestingModule } from '@nestjs/testing';
+import { NotFoundException } from '@nestjs/common';
 import { LimitsService } from './limits.service';
 import { PrismaService } from '../prisma/prisma.service';
 
 describe('LimitsService', () => {
   let service: LimitsService;
   let prisma: any;
 
+  const walletId = 'wallet-uuid-1';
+
   beforeEach(async () => {
     prisma = {
-      userLimit: {
+      walletLimit: {
         upsert: jest.fn(),
         findUnique: jest.fn(),
+        delete: jest.fn(),
       },
-      payment: {
-        aggregate: jest.fn(),
+      transaction: {
+        findMany: jest.fn(),
       },
     };
 
@@ -29,50 +33,88 @@ describe('LimitsService', () => {
   });
 
   describe('setLimits', () => {
-    it('should upsert limits', async () => {
-      await service.setLimits(1, 100, 10);
-      expect(prisma.userLimit.upsert).toHaveBeenCalledWith({
-        where: { userId: 1 },
+    it('should upsert wallet limits', async () => {
+      await service.setLimits(walletId, 100, 10);
+      expect(prisma.walletLimit.upsert).toHaveBeenCalledWith({
+        where: { walletId },
         update: { dailyLimit: 100, perTransactionLimit: 10 },
-        create: { userId: 1, dailyLimit: 100, perTransactionLimit: 10 },
+        create: { walletId, dailyLimit: 100, perTransactionLimit: 10 },
       });
     });
   });
 
+  describe('getLimits', () => {
+    it('should return limits for a wallet', async () => {
+      const limit = { walletId, dailyLimit: 100, perTransactionLimit: 10 };
+      prisma.walletLimit.findUnique.mockResolvedValue(limit);
+      const result = await service.getLimits(walletId);
+      expect(result).toEqual(limit);
+      expect(prisma.walletLimit.findUnique).toHaveBeenCalledWith({ where: { walletId } });
+    });
+  });
+
   describe('checkLimits', () => {
     it('should pass if no limits set', async () => {
-      prisma.userLimit.findUnique.mockResolvedValue(null);
-      await expect(service.checkLimits(1, 100)).resolves.not.toThrow();
+      prisma.walletLimit.findUnique.mockResolvedValue(null);
+      await expect(service.checkLimits(walletId, 100)).resolves.not.toThrow();
     });
 
-    it('should throw if per transaction limit exceeded', async () => {
-      prisma.userLimit.findUnique.mockResolvedValue({
+    it('should throw if per-transaction limit exceeded', async () => {
+      prisma.walletLimit.findUnique.mockResolvedValue({
         perTransactionLimit: 50,
         dailyLimit: 1000,
       });
-      await expect(service.checkLimits(1, 100)).rejects.toThrow(
+      await expect(service.checkLimits(walletId, 100)).rejects.toThrow(
         'Transaction limit exceeded',
       );
     });
 
     it('should throw if daily limit exceeded', async () => {
-      prisma.userLimit.findUnique.mockResolvedValue({
+      prisma.walletLimit.findUnique.mockResolvedValue({
         perTransactionLimit: 200,
         dailyLimit: 100,
       });
-      prisma.payment.aggregate.mockResolvedValue({ _sum: { amount: 50 } });
-      await expect(service.checkLimits(1, 60)).rejects.toThrow(
+      prisma.transaction.findMany.mockResolvedValue([{ amount: '50' }]);
+      await expect(service.checkLimits(walletId, 60)).rejects.toThrow(
         'Daily limit exceeded',
       );
     });
 
     it('should pass if within limits', async () => {
-      prisma.userLimit.findUnique.mockResolvedValue({
+      prisma.walletLimit.findUnique.mockResolvedValue({
         perTransactionLimit: 200,
         dailyLimit: 100,
       });
-      prisma.payment.aggregate.mockResolvedValue({ _sum: { amount: 40 } });
-      await expect(service.checkLimits(1, 50)).resolves.not.toThrow();
+      prisma.transaction.findMany.mockResolvedValue([{ amount: '40' }]);
+      await expect(service.checkLimits(walletId, 50)).resolves.not.toThrow();
+    });
+
+    it('should aggregate transactions by senderWalletId since start of day', async () => {
+      prisma.walletLimit.findUnique.mockResolvedValue({
+        perTransactionLimit: 200,
+        dailyLimit: 1000,
+      });
+      prisma.transaction.findMany.mockResolvedValue([]);
+      await service.checkLimits(walletId, 50);
+
+      const call = prisma.transaction.findMany.mock.calls[0][0];
+      expect(call.where.senderWalletId).toBe(walletId);
+      expect(call.where.createdAt.gte).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('removeLimits', () => {
+    it('should delete limits for a wallet', async () => {
+      const limit = { walletId, dailyLimit: 100, perTransactionLimit: 10 };
+      prisma.walletLimit.findUnique.mockResolvedValue(limit);
+      prisma.walletLimit.delete.mockResolvedValue(limit);
+      await service.removeLimits(walletId);
+      expect(prisma.walletLimit.delete).toHaveBeenCalledWith({ where: { walletId } });
+    });
+
+    it('should throw NotFoundException if no limits exist', async () => {
+      prisma.walletLimit.findUnique.mockResolvedValue(null);
+      await expect(service.removeLimits(walletId)).rejects.toThrow(NotFoundException);
     });
   });
 });

src/limits/limits.service.ts

@@ -1,29 +1,25 @@
-import { Injectable } from '@nestjs/common';
-import { CreateLimitDto } from './dto/create-limit.dto';
-import { UpdateLimitDto } from './dto/update-limit.dto';
+import { Injectable, NotFoundException } from '@nestjs/common';
 import { PrismaService } from '../prisma/prisma.service';
 
 @Injectable()
 export class LimitsService {
   constructor(private readonly prisma: PrismaService) {}
 
-  async setLimits(userId: number, daily: number, perTx: number) {
-    return this.prisma.userLimit.upsert({
-      where: { userId },
+  async setLimits(walletId: string, daily: number, perTx: number) {
+    return this.prisma.walletLimit.upsert({
+      where: { walletId },
       update: { dailyLimit: daily, perTransactionLimit: perTx },
-      create: { userId, dailyLimit: daily, perTransactionLimit: perTx },
+      create: { walletId, dailyLimit: daily, perTransactionLimit: perTx },
     });
   }
 
-  async getLimits(userId: number) {
-    return this.prisma.userLimit.findUnique({
-      where: { userId },
-    });
+  async getLimits(walletId: string) {
+    return this.prisma.walletLimit.findUnique({ where: { walletId } });
   }
 
-  async checkLimits(userId: number, amount: number): Promise<void> {
-    const limits = await this.getLimits(userId);
-    if (!limits) return; // No limits set
+  async checkLimits(walletId: string, amount: number): Promise<void> {
+    const limits = await this.getLimits(walletId);
+    if (!limits) return;
 
     if (amount > limits.perTransactionLimit) {
       throw new Error(
@@ -34,43 +30,22 @@ export class LimitsService {
     const startOfDay = new Date();
     startOfDay.setHours(0, 0, 0, 0);
 
-    const usage = await this.prisma.payment.aggregate({
-      where: {
-        fromId: userId,
-        createdAt: {
-          gte: startOfDay,
-        },
-      },
-      _sum: {
-        amount: true,
-      },
+    const txns = await this.prisma.transaction.findMany({
+      where: { senderWalletId: walletId, createdAt: { gte: startOfDay } },
+      select: { amount: true },
     });
 
-    const currentDailyTotal = usage._sum.amount || 0;
+    const currentDailyTotal = txns.reduce((sum, t) => sum + Number(t.amount), 0);
     if (currentDailyTotal + amount > limits.dailyLimit) {
       throw new Error(
         `Daily limit exceeded. Limit: ${limits.dailyLimit}, Used: ${currentDailyTotal}`,
       );
     }
   }
 
-  create(createLimitDto: CreateLimitDto) {
-    return 'This action adds a new limit';
-  }
-
-  findAll() {
-    return `This action returns all limits`;
-  }
-
-  findOne(id: number) {
-    return `This action returns a #${id} limit`;
-  }
-
-  update(id: number, updateLimitDto: UpdateLimitDto) {
-    return `This action updates a #${id} limit`;
-  }
-
-  remove(id: number) {
-    return `This action removes a #${id} limit`;
+  async removeLimits(walletId: string) {
+    const existing = await this.getLimits(walletId);
+    if (!existing) throw new NotFoundException(`No limits found for wallet ${walletId}`);
+    return this.prisma.walletLimit.delete({ where: { walletId } });
   }
 }