Merge pull request #148 from Tria-plc/feat/payment-microservice

refactor: ( payment ) use rabbitmq for webhooks event

apps/edr-passenger-api/.env.example

@@ -116,3 +116,12 @@ FAYDA_CLAIMS_LOCALES=en am
 FAYDA_SESSION_TTL_MINUTES=10
 
 GITHUB_PACKAGE_TOKEN=
+
+# --- Payment event consumer (RabbitMQ) -------------------------------------------------------
+# Consumes payment.succeeded / payment.failed events from the payment microservice. Separate
+# from any RABBITMQ_URL used by the IAM/notification modules so the two connections are
+# independent. Points at the dedicated `payment` vhost on the (shared) broker.
+# Local dev broker (docker): amqp://edr:edr_secret@localhost:5672/payment
+PAYMENT_RABBITMQ_URL=amqp://edr:edr_secret@localhost:5672/payment
+# Max unacknowledged payment events this consumer holds at once.
+PAYMENT_EVENTS_PREFETCH=10

apps/edr-passenger-api/package.json

@@ -22,6 +22,7 @@
 
   "dependencies": {
     "@edr/types": "workspace:*",
+    "@golevelup/nestjs-rabbitmq": "^5.5.0",
     "@nestjs/axios": "^4.0.1",
     "@nestjs/common": "^11.0.0",
     "@nestjs/config": "^4.0.4",

apps/edr-passenger-api/src/app.module.ts

@@ -15,6 +15,7 @@ import ebirrConfig from './config/ebirr.config';
 import cardConfig from './config/card.config';
 import waafiConfig from './config/waafi.config';
 import faydaConfig from './config/fayda.config';
+import rabbitmqConfig from './config/rabbitmq.config';
 import { AuthModule } from './modules/auth/auth.module';
 import { StationsModule } from './modules/stations/stations.module';
 import { FleetModule } from './modules/fleet/fleet.module';
@@ -54,6 +55,7 @@ import { AuditModuleFeature } from './modules/audit/audit.module';
         cardConfig,
         waafiConfig,
         faydaConfig,
+        rabbitmqConfig,
       ],
     }),
     ScheduleModule.forRoot(),

apps/edr-passenger-api/src/common/filters/http-exception.filter.ts

@@ -12,6 +12,12 @@ export class HttpExceptionFilter implements ExceptionFilter {
   private readonly logger = new Logger(HttpExceptionFilter.name);
 
   catch(exception: unknown, host: ArgumentsHost): void {
+    // Global filter — also reached by non-HTTP (e.g. RabbitMQ) handlers. switchToHttp() would
+    // yield no response object there, so re-throw and let the transport (golevelup) handle it
+    // (nack/dead-letter) instead of crashing on response.status().
+    if (host.getType() !== 'http') {
+      throw exception;
+    }
     const ctx = host.switchToHttp();
     const response = ctx.getResponse();
     const request = ctx.getRequest();

apps/edr-passenger-api/src/common/interceptors/response-transform.interceptor.ts

@@ -4,7 +4,14 @@ import { map } from 'rxjs/operators';
 
 @Injectable()
 export class ResponseTransformInterceptor<T> implements NestInterceptor<T, any> {
-  intercept(_ctx: ExecutionContext, next: CallHandler<T>): Observable<any> {
+  intercept(ctx: ExecutionContext, next: CallHandler<T>): Observable<any> {
+    // Only wrap HTTP responses. This interceptor is global, so it also runs for RabbitMQ
+    // message handlers (golevelup uses Nest's context system) — there, wrapping the return
+    // value would corrupt the handler's contract (e.g. a returned Nack would be swallowed,
+    // dropping a message instead of dead-lettering it). Let non-HTTP returns pass through.
+    if (ctx.getType() !== 'http') {
+      return next.handle();
+    }
     return next.handle().pipe(
       map((data) => ({ success: true, data, timestamp: new Date().toISOString() })),
     );

apps/edr-passenger-api/src/config/rabbitmq.config.ts

@@ -0,0 +1,12 @@
+import { registerAs } from '@nestjs/config';
+
+/**
+ * RabbitMQ connection for the payment-event consumer (payment microservice -> passenger).
+ * Independent of the IAM/notification module's RABBITMQ_URL so the two broker connections
+ * never interfere. Points at the dedicated `payment` vhost on the shared broker.
+ */
+export default registerAs('rabbitmq', () => ({
+  url: process.env.PAYMENT_RABBITMQ_URL ?? 'amqp://localhost:5672/payment',
+  /** Max unacked payment events held by this consumer at once. */
+  prefetch: parseInt(process.env.PAYMENT_EVENTS_PREFETCH ?? '10', 10),
+}));

apps/edr-passenger-api/src/modules/payments/payment-events.consumer.ts

@@ -0,0 +1,47 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Nack, RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
+import {
+  PAYMENT_EVENTS_DLX,
+  PAYMENT_EVENTS_EXCHANGE,
+  PAYMENT_QUEUES,
+  PaymentEvent,
+  PaymentService,
+  paymentServiceBindingPattern,
+} from '@edr/types';
+import { PaymentEventDto } from './internal-payments.dto';
+import { PaymentsService } from './payments.service';
+
+const PASSENGER_QUEUE = PAYMENT_QUEUES[PaymentService.PASSENGER];
+
+@Injectable()
+export class PaymentEventsConsumer {
+  private readonly logger = new Logger(PaymentEventsConsumer.name);
+
+  constructor(private readonly paymentsService: PaymentsService) {}
+
+  @RabbitSubscribe({
+    exchange: PAYMENT_EVENTS_EXCHANGE,
+    routingKey: paymentServiceBindingPattern(PaymentService.PASSENGER), // payment.passenger.*
+    queue: PASSENGER_QUEUE.main,
+    queueOptions: {
+      durable: true,
+      deadLetterExchange: PAYMENT_EVENTS_DLX,
+    },
+  })
+  async handle(event: PaymentEvent): Promise<Nack | void> {
+    try {
+      const result = await this.paymentsService.handlePaymentEvent(
+        event as unknown as PaymentEventDto,
+      );
+      this.logger.log(
+        `processed ${event.eventType} (${event.eventId}) ref=${event.referenceId}: ${JSON.stringify(result)}`,
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.error(
+        `DEAD-LETTERING ${event.eventType} (${event.eventId}) ref=${event.referenceId}: ${message}`,
+      );
+      return new Nack(false);
+    }
+  }
+}

apps/edr-passenger-api/src/modules/payments/payments.module.ts

@@ -1,25 +1,61 @@
 import { Module } from "@nestjs/common";
 import { HttpModule } from "@nestjs/axios";
+import { ConfigService } from "@nestjs/config";
+import { RabbitMQModule } from "@golevelup/nestjs-rabbitmq";
+import {
+  PAYMENT_EVENTS_DLX,
+  PAYMENT_EVENTS_EXCHANGE,
+  PAYMENT_QUEUES,
+  PaymentService,
+  paymentServiceBindingPattern,
+} from "@edr/types";
 import { PaymentsController } from "./payments.controller";
 import { PaymentsService } from "./payments.service";
 import { InternalPaymentsController } from "./internal-payments.controller";
 import { PaymentClientService } from "./payment-client.service";
+import { PaymentEventsConsumer } from "./payment-events.consumer";
 import { ServiceAuthGuard } from "../../common/guards/service-auth.guard";
 import { SeatsModule } from "../seats/seats.module";
 import { TicketsModule } from "../tickets/tickets.module";
 
-/**
- * Post-cutover (docs/payment-service phase 6): provider gateways and webhook handlers live in
- * apps/edr-payment-api. This module keeps domain validation, the WALLET flow, the payment
- * client, and the idempotent mark-paid consumer.
- */
+const PASSENGER_QUEUE = PAYMENT_QUEUES[PaymentService.PASSENGER];
+
 @Module({
   imports: [
     SeatsModule,
     TicketsModule,
     HttpModule.register({ timeout: 10_000 }),
+    RabbitMQModule.forRootAsync({
+      inject: [ConfigService],
+      useFactory: (config: ConfigService) => ({
+        uri: config.get<string>("rabbitmq.url") as string,
+        exchanges: [
+          {
+            name: PAYMENT_EVENTS_EXCHANGE,
+            type: "topic",
+            options: { durable: true },
+          },
+          { name: PAYMENT_EVENTS_DLX, type: "topic", options: { durable: true } },
+        ],
+        queues: [
+          {
+            name: PASSENGER_QUEUE.dlq,
+            exchange: PAYMENT_EVENTS_DLX,
+            routingKey: paymentServiceBindingPattern(PaymentService.PASSENGER),
+            options: { durable: true },
+          },
+        ],
+        prefetchCount: config.get<number>("rabbitmq.prefetch") ?? 10,
+        connectionInitOptions: { wait: false },
+      }),
+    }),
   ],
   controllers: [PaymentsController, InternalPaymentsController],
-  providers: [PaymentsService, PaymentClientService, ServiceAuthGuard],
+  providers: [
+    PaymentsService,
+    PaymentClientService,
+    PaymentEventsConsumer,
+    ServiceAuthGuard,
+  ],
 })
 export class PaymentsModule {}

apps/edr-payment-api/package.json

@@ -20,6 +20,7 @@
     "@edr/api-common": "workspace:*",
     "@edr/payment-providers": "workspace:*",
     "@edr/types": "workspace:*",
+    "@golevelup/nestjs-rabbitmq": "^5.5.0",
     "@nestjs/axios": "^4.0.1",
     "@nestjs/common": "^11.0.0",
     "@nestjs/config": "^4.0.0",

apps/edr-payment-api/src/app.module.ts

@@ -5,6 +5,7 @@ import { TypeOrmModule, TypeOrmModuleOptions } from "@nestjs/typeorm";
 import appConfig from "./config/app.config";
 import databaseConfig from "./config/database.config";
 import notifierConfig from "./config/notifier.config";
+import rabbitmqConfig from "./config/rabbitmq.config";
 import telebirrConfig from "./config/telebirr.config";
 import waafiConfig from "./config/waafi.config";
 import cbeConfig from "./config/cbe.config";
@@ -26,6 +27,7 @@ import { WebhooksModule } from "./modules/webhooks/webhooks.module";
         appConfig,
         databaseConfig,
         notifierConfig,
+        rabbitmqConfig,
         telebirrConfig,
         waafiConfig,
         cbeConfig,

apps/edr-payment-api/src/config/rabbitmq.config.ts

@@ -0,0 +1,23 @@
+import { registerAs } from "@nestjs/config";
+
+/**
+ * RabbitMQ connection for the outbox event publisher (payment -> apps).
+ * `publisherTransport` selects which PaymentEventPublisher the outbox relay uses:
+ *   "rabbitmq" -> RabbitMqPaymentEventPublisher (publish to the payment.events exchange) [DEFAULT]
+ *   "http"     -> HttpPaymentEventPublisher (POST to each app's mark-paid endpoint) [rollback]
+ * RabbitMQ is the default; set PUBLISHER_TRANSPORT=http explicitly to fall back to HTTP.
+ */
+export default registerAs("rabbitmq", () => ({
+  url: process.env.PAYMENT_RABBITMQ_URL ?? "amqp://localhost:5672/payment",
+  publisherTransport: (process.env.PUBLISHER_TRANSPORT ?? "rabbitmq").toLowerCase(),
+  /** Publish is failed (so the relay retries) if the broker does not confirm within this. */
+  publishTimeoutMs: parseInt(process.env.PAYMENT_PUBLISH_TIMEOUT_MS ?? "10000", 10),
+}));
+
+/**
+ * True when the outbox relay should publish to RabbitMQ rather than POST over HTTP.
+ * RabbitMQ is the default; only an explicit PUBLISHER_TRANSPORT=http opts out.
+ */
+export function isRabbitPublisher(): boolean {
+  return (process.env.PUBLISHER_TRANSPORT ?? "rabbitmq").toLowerCase() !== "http";
+}

apps/edr-payment-api/src/modules/outbox/outbox.module.ts

@@ -1,19 +1,56 @@
 import { Module } from "@nestjs/common";
 import { HttpModule } from "@nestjs/axios";
+import { ConfigService } from "@nestjs/config";
 import { TypeOrmModule } from "@nestjs/typeorm";
+import { RabbitMQModule } from "@golevelup/nestjs-rabbitmq";
+import { PAYMENT_EVENTS_DLX, PAYMENT_EVENTS_EXCHANGE } from "@edr/types";
+import { isRabbitPublisher } from "../../config/rabbitmq.config";
 import { NotificationOutbox } from "./entities/notification-outbox.entity";
 import { OutboxRelayService } from "./outbox-relay.service";
 import { OutboxRepository } from "./outbox.repository";
 import { HttpPaymentEventPublisher } from "./publisher/http-payment-event-publisher";
 import { PAYMENT_EVENT_PUBLISHER } from "./publisher/payment-event-publisher";
+import { RabbitMqPaymentEventPublisher } from "./publisher/rabbitmq-payment-event-publisher";
+
+const rabbitImports = isRabbitPublisher()
+  ? [
+      RabbitMQModule.forRootAsync({
+        inject: [ConfigService],
+        useFactory: (config: ConfigService) => ({
+          uri: config.get<string>("rabbitmq.url") as string,
+          exchanges: [
+            {
+              name: PAYMENT_EVENTS_EXCHANGE,
+              type: "topic",
+              options: { durable: true },
+            },
+            {
+              name: PAYMENT_EVENTS_DLX,
+              type: "topic",
+              options: { durable: true },
+            },
+          ],
+          connectionInitOptions: { wait: false },
+        }),
+      }),
+    ]
+  : [];
 
 @Module({
-  imports: [TypeOrmModule.forFeature([NotificationOutbox]), HttpModule],
+  imports: [
+    TypeOrmModule.forFeature([NotificationOutbox]),
+    HttpModule,
+    ...rabbitImports,
+  ],
   providers: [
     OutboxRepository,
     OutboxRelayService,
-    // Swap to RabbitPaymentEventPublisher here when the broker lands — nothing else changes.
-    { provide: PAYMENT_EVENT_PUBLISHER, useClass: HttpPaymentEventPublisher },
+    {
+      provide: PAYMENT_EVENT_PUBLISHER,
+      useClass: isRabbitPublisher()
+        ? RabbitMqPaymentEventPublisher
+        : HttpPaymentEventPublisher,
+    },
   ],
   exports: [OutboxRepository],
 })

apps/edr-payment-api/src/modules/outbox/publisher/rabbitmq-payment-event-publisher.ts

@@ -0,0 +1,61 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+import { AmqpConnection } from "@golevelup/nestjs-rabbitmq";
+import {
+  PAYMENT_EVENTS_EXCHANGE,
+  PaymentEvent,
+  paymentRoutingKey,
+} from "@edr/types";
+import { PaymentEventPublisher } from "./payment-event-publisher";
+
+@Injectable()
+export class RabbitMqPaymentEventPublisher implements PaymentEventPublisher {
+  private readonly logger = new Logger(RabbitMqPaymentEventPublisher.name);
+  private readonly publishTimeoutMs: number;
+
+  constructor(
+    private readonly amqp: AmqpConnection,
+    config: ConfigService,
+  ) {
+    this.publishTimeoutMs =
+      config.get<number>("rabbitmq.publishTimeoutMs") ?? 10_000;
+  }
+
+  async publish(event: PaymentEvent): Promise<void> {
+    const routingKey = paymentRoutingKey(event.service, event.eventType);
+
+    const confirmed = await this.withTimeout(
+      this.amqp.publish(PAYMENT_EVENTS_EXCHANGE, routingKey, event, {
+        persistent: true,
+        messageId: event.eventId,
+        contentType: "application/json",
+        type: event.eventType,
+        headers: { "x-event-version": event.version },
+      }),
+    );
+
+    if (!confirmed) {
+      throw new Error(
+        `broker did not confirm publish of ${event.eventType} (${event.eventId})`,
+      );
+    }
+
+    this.logger.log(
+      `published ${event.eventType} (${event.eventId}) -> ${routingKey}`,
+    );
+  }
+
+  private withTimeout(p: Promise<boolean>): Promise<boolean> {
+    let timer: NodeJS.Timeout;
+    const timeout = new Promise<boolean>((_, reject) => {
+      timer = setTimeout(
+        () =>
+          reject(
+            new Error(`publish confirm timed out after ${this.publishTimeoutMs}ms`),
+          ),
+        this.publishTimeoutMs,
+      );
+    });
+    return Promise.race([p, timeout]).finally(() => clearTimeout(timer));
+  }
+}