Emit payment and limit domain events through webhooks

Author: yosemite01

src/limits/limits.module.ts

@@ -2,9 +2,10 @@ import { Module } from '@nestjs/common';
 import { LimitsService } from './limits.service';
 import { LimitsController } from './limits.controller';
 import { PrismaModule } from '../prisma/prisma.module';
+import { WebhookModule } from '../webhooks/webhook.module';
 
 @Module({
-  imports: [PrismaModule],
+  imports: [PrismaModule, WebhookModule],
   controllers: [LimitsController],
   providers: [LimitsService],
   exports: [LimitsService],

src/limits/limits.service.ts

@@ -5,6 +5,7 @@ import {
   HttpStatus,
 } from '@nestjs/common';
 import { PrismaService } from '../prisma/prisma.service';
+import { WebhookEventEmitterService } from '../webhooks/webhook-event-emitter.service';
 import { CreateLimitDto, LimitPeriod } from './dto/create-limit.dto';
 import { UpdateLimitDto } from './dto/update-limit.dto';
 
@@ -27,14 +28,25 @@ export class LimitExceededException extends HttpException {
 
 @Injectable()
 export class LimitsService {
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly webhookEventEmitter: WebhookEventEmitterService,
+  ) {}
 
   async setLimits(walletId: string, daily: number, perTx: number) {
-    return this.prisma.walletLimit.upsert({
+    const limits = await this.prisma.walletLimit.upsert({
       where: { walletId },
       update: { dailyLimit: daily, perTransactionLimit: perTx },
       create: { walletId, dailyLimit: daily, perTransactionLimit: perTx },
     });
+
+    await this.webhookEventEmitter.emitLimitsUpdated({
+      walletId,
+      dailyLimit: limits.dailyLimit,
+      perTransactionLimit: limits.perTransactionLimit,
+    });
+
+    return limits;
   }
 
   async getLimits(walletId: string) {

src/payments/payments.module.ts

@@ -3,9 +3,10 @@ import { PaymentsService } from './payments.service';
 import { PaymentsController } from './payments.controller';
 import { LimitsModule } from '../limits/limits.module';
 import { WalletsModule } from '../wallets/wallets.module';
+import { WebhookModule } from '../webhooks/webhook.module';
 
 @Module({
-  imports: [LimitsModule, WalletsModule],
+  imports: [LimitsModule, WalletsModule, WebhookModule],
   controllers: [PaymentsController],
   providers: [PaymentsService],
 })

src/payments/payments.service.ts

@@ -12,6 +12,7 @@ import { WalletStatus } from '../wallets/domain/wallet.model';
 import { PaymentStatus } from './entities/payment.entity';
 import { PaginationDto, PaginatedResponse } from '../common/dto/pagination.dto';
 import { PaymentsFilterDto } from './dto/payments-filter.dto';
+import { WebhookEventEmitterService } from '../webhooks/webhook-event-emitter.service';
 
 // Only PENDING payments can be transitioned; terminal states are immutable.
 const ALLOWED_TRANSITIONS: Record<string, PaymentStatus[]> = {
@@ -26,6 +27,7 @@ export class PaymentsService {
     private readonly prisma: PrismaService,
     private readonly limitsService: LimitsService,
     private readonly walletsService: WalletsService,
+    private readonly webhookEventEmitter: WebhookEventEmitterService,
   ) {}
 
   async create(createPaymentDto: CreatePaymentDto) {
@@ -49,7 +51,7 @@ export class PaymentsService {
     await this.walletsService.findWalletById(receiverWalletId);
     await this.limitsService.checkLimits(walletId, amount);
 
-    return this.prisma.payment.create({
+    const payment = await this.prisma.payment.create({
       data: {
         fromId,
         toId,
@@ -60,6 +62,17 @@ export class PaymentsService {
         status: PaymentStatus.PENDING,
       },
     });
+
+    await this.webhookEventEmitter.emitPaymentCreated({
+      paymentId: payment.id,
+      walletId,
+      receiverWalletId,
+      amount,
+      currency,
+      status: payment.status,
+    });
+
+    return payment;
   }
 
   async findAll(
@@ -114,10 +127,21 @@ export class PaymentsService {
       }
     }
 
-    return this.prisma.payment.update({
+    const updatedPayment = await this.prisma.payment.update({
       where: { id: paymentId },
       data: updatePaymentDto,
     });
+
+    if (updatePaymentDto.status !== undefined) {
+      await this.webhookEventEmitter.emitPaymentStatusUpdated({
+        paymentId: updatedPayment.id,
+        walletId: String(updatedPayment.fromId),
+        previousStatus: payment.status,
+        status: updatedPayment.status,
+      });
+    }
+
+    return updatedPayment;
   }
 
   remove(id: string) {

src/webhooks/domain/webhook-events.ts

@@ -23,6 +23,13 @@ export enum WebhookEventType {
   // User events
   USER_CREATED = 'user.created',
   USER_UPDATED = 'user.updated',
+
+  // Payment events
+  PAYMENT_CREATED = 'payment.created',
+  PAYMENT_STATUS_UPDATED = 'payment.status.updated',
+
+  // Limit events
+  LIMITS_UPDATED = 'limits.updated',
 }
 
 export interface WebhookEvent {

src/webhooks/webhook-event-emitter.service.ts

@@ -177,6 +177,50 @@ export class WebhookEventEmitterService {
     await this.webhookDispatcher.dispatchEvent({ event });
   }
 
+  /**
+   * Emits a payment.created event
+   */
+  async emitPaymentCreated(data: {
+    paymentId: string | number;
+    walletId: string;
+    receiverWalletId: string;
+    amount: string | number;
+    currency: string;
+    status: string;
+  }): Promise<void> {
+    const event = this.createEvent(WebhookEventType.PAYMENT_CREATED, data);
+    await this.webhookDispatcher.dispatchEvent({ event });
+  }
+
+  /**
+   * Emits a payment.status.updated event
+   */
+  async emitPaymentStatusUpdated(data: {
+    paymentId: string | number;
+    walletId: string;
+    previousStatus: string;
+    status: string;
+    reason?: string;
+  }): Promise<void> {
+    const event = this.createEvent(
+      WebhookEventType.PAYMENT_STATUS_UPDATED,
+      data,
+    );
+    await this.webhookDispatcher.dispatchEvent({ event });
+  }
+
+  /**
+   * Emits a limits.updated event
+   */
+  async emitLimitsUpdated(data: {
+    walletId: string;
+    dailyLimit: number;
+    perTransactionLimit: number;
+  }): Promise<void> {
+    const event = this.createEvent(WebhookEventType.LIMITS_UPDATED, data);
+    await this.webhookDispatcher.dispatchEvent({ event });
+  }
+
   /**
    * Creates a webhook event with standard structure
    */