refactor: improve PaymentService and TransactionsController with DI and better SoC

Author: gabaoun

app/controllers/transactions_controller.ts

@@ -1,11 +1,13 @@
 import { type HttpContext } from '@adonisjs/core/http'
+import { inject } from '@adonisjs/core'
 import Transaction from '#models/transaction'
 import Product from '#models/product'
 import { PaymentService } from '#services/payment_service'
 import vine from '@vinejs/vine'
 
+@inject()
 export default class TransactionsController {
-  private paymentService = new PaymentService()
+  constructor(private paymentService: PaymentService) {}
 
   public async purchase({ request, response }: HttpContext) {
     const schema = vine.compile(
@@ -31,21 +33,11 @@ export default class TransactionsController {
 
     const payload = await request.validateUsing(schema)
 
-    const items = await Promise.all(
-      payload.products.map(async (p) => {
-        const product = await Product.findOrFail(p.id)
-        return { id: product.id, quantity: p.quantity, price: product.amount }
-      })
-    )
-
-    const total = items.reduce((acc, item) => acc + item.price * item.quantity, 0)
-
     try {
-      const transaction = await this.paymentService.processPayment(
-        payload.client,
-        { ...payload.payment, products: items },
-        total
-      )
+      const transaction = await this.paymentService.processPayment(payload.client, {
+        ...payload.payment,
+        products: payload.products,
+      })
 
       return response.ok(transaction)
     } catch (e) {

app/services/payment_service.ts

@@ -1,100 +1,162 @@
+import { inject } from '@adonisjs/core'
 import Gateway from '#models/gateway'
 import Transaction from '#models/transaction'
 import Client from '#models/client'
+import Product from '#models/product'
 import { GatewayOne } from './gateways/gateway_one.js'
 import { GatewayTwo } from './gateways/gateway_two.js'
 import { type PaymentGateway, type PaymentRequest } from './gateways/payment_gateway.js'
 
+@inject()
 export class PaymentService {
-  private gateways: Record<string, PaymentGateway> = {
+  private gatewayInstances: Record<string, PaymentGateway> = {
     'Gateway 1': new GatewayOne(),
     'Gateway 2': new GatewayTwo(),
   }
 
+  /**
+   * Orchestrates the payment process across multiple gateways with fallback support.
+   */
   public async processPayment(
     customer: { name: string; email: string },
-    payment: { cardNumber: string; cvv: string; products: { id: number; quantity: number }[] },
-    amount: number
+    payment: { cardNumber: string; cvv: string; products: { id: number; quantity: number }[] }
   ) {
-    const client = await Client.firstOrCreate({ email: customer.email }, { name: customer.name })
-
-    const providers = await Gateway.query().where('isActive', true).orderBy('priority', 'asc')
+    const amount = await this.calculateTotal(payment.products)
+    const client = await this.getOrCreateClient(customer)
+    const activeGateways = await this.getActiveGatewaysSortedByPriority()
 
-    if (!providers.length) {
-      throw new Error('Nenhum gateway de pagamento configurado ou ativo')
+    if (!activeGateways.length) {
+      throw new Error('No payment gateways configured or active')
     }
 
-    const transaction = await Transaction.create({
-      clientId: client.id,
-      amount,
-      status: 'PENDING',
-      cardLastNumbers: payment.cardNumber.slice(-4),
-    })
+    const transaction = await this.createPendingTransaction(client.id, amount, payment.cardNumber)
+    await this.attachProductsToTransaction(transaction, payment.products)
 
-    for (const p of payment.products) {
-      await transaction.related('products').attach({ [p.id]: { quantity: p.quantity } })
-    }
-
-    const request: PaymentRequest = {
-      amount,
-      name: client.name,
-      email: client.email,
-      cardNumber: payment.cardNumber,
-      cvv: payment.cvv,
-    }
+    const paymentRequest = this.buildPaymentRequest(client, payment, amount)
 
     let success = false
-    let errorLog = ''
+    let lastError = 'Unknown error'
 
-    for (const model of providers) {
-      const instance = this.gateways[model.name]
+    for (const gatewayModel of activeGateways) {
+      const instance = this.gatewayInstances[gatewayModel.name]
       if (!instance) continue
 
-      const res = await instance.pay(request)
+      const result = await instance.pay(paymentRequest)
 
-      if (res.success) {
-        transaction.merge({
-          status: 'PAID',
-          gatewayId: model.id,
-          externalId: res.externalId,
-        })
-        await transaction.save()
+      if (result.success) {
+        await this.finalizeTransaction(transaction, gatewayModel.id, result.externalId!)
         success = true
         break
       }
 
-      errorLog = res.error || 'Erro desconhecido'
+      lastError = result.error || 'Payment failed'
     }
 
     if (!success) {
-      transaction.status = 'FAILED'
-      await transaction.save()
-      throw new Error(`Falha no processamento: ${errorLog}`)
+      await this.markTransactionAsFailed(transaction)
+      throw new Error(`Payment processing failed: ${lastError}`)
     }
 
     return transaction
   }
 
-  public async refund(id: number) {
-    const transaction = await Transaction.query().where('id', id).preload('gateway').firstOrFail()
+  /**
+   * Calculates the total amount for a list of products.
+   */
+  public async calculateTotal(items: { id: number; quantity: number }[]): Promise<number> {
+    const products = await Promise.all(
+      items.map(async (item) => {
+        const product = await Product.findOrFail(item.id)
+        return product.amount * item.quantity
+      })
+    )
+    return products.reduce((acc, current) => acc + current, 0)
+  }
+
+  /**
+   * Refunds a paid transaction using the gateway that processed it.
+   */
+  public async refund(transactionId: number) {
+    const transaction = await Transaction.query()
+      .where('id', transactionId)
+      .preload('gateway')
+      .firstOrFail()
 
     if (transaction.status !== 'PAID') {
-      throw new Error('Apenas transações pagas podem ser reembolsadas')
+      throw new Error('Only paid transactions can be refunded')
     }
 
-    const instance = this.gateways[transaction.gateway?.name || '']
+    const instance = this.gatewayInstances[transaction.gateway?.name || '']
     if (!instance) {
-      throw new Error('Implementação do gateway não encontrada para estorno')
+      throw new Error('Gateway implementation not found for refund')
     }
 
-    const res = await instance.refund(transaction.externalId!)
+    const result = await instance.refund(transaction.externalId!)
 
-    if (res.success) {
+    if (result.success) {
       transaction.status = 'REFUNDED'
       await transaction.save()
       return true
     }
 
-    throw new Error(`Falha no estorno: ${res.error}`)
+    throw new Error(`Refund failed: ${result.error}`)
+  }
+
+  private async getOrCreateClient(customer: { name: string; email: string }) {
+    return await Client.firstOrCreate({ email: customer.email }, { name: customer.name })
+  }
+
+  private async getActiveGatewaysSortedByPriority() {
+    return await Gateway.query().where('isActive', true).orderBy('priority', 'asc')
+  }
+
+  private async createPendingTransaction(clientId: number, amount: number, cardNumber: string) {
+    return await Transaction.create({
+      clientId,
+      amount,
+      status: 'PENDING',
+      cardLastNumbers: cardNumber.slice(-4),
+    })
+  }
+
+  private async attachProductsToTransaction(
+    transaction: Transaction,
+    products: { id: number; quantity: number }[]
+  ) {
+    for (const p of products) {
+      await transaction.related('products').attach({ [p.id]: { quantity: p.quantity } })
+    }
+  }
+
+  private buildPaymentRequest(
+    client: Client,
+    payment: { cardNumber: string; cvv: string },
+    amount: number
+  ): PaymentRequest {
+    return {
+      amount,
+      name: client.name,
+      email: client.email,
+      cardNumber: payment.cardNumber,
+      cvv: payment.cvv,
+    }
+  }
+
+  private async finalizeTransaction(
+    transaction: Transaction,
+    gatewayId: number,
+    externalId: string
+  ) {
+    transaction.merge({
+      status: 'PAID',
+      gatewayId,
+      externalId,
+    })
+    await transaction.save()
+  }
+
+  private async markTransactionAsFailed(transaction: Transaction) {
+    transaction.status = 'FAILED'
+    await transaction.save()
   }
 }