chore: add logging, outgoing payment service changes

packages/backend/src/open_payments/payment/outgoing/lifecycle.ts

@@ -7,6 +7,7 @@ import {
 } from './model'
 import { ServiceDependencies } from './service'
 import { Receiver } from '../../receiver/model'
+import { TransactionOrKnex } from 'objection'
 
 // "payment" is locked by the "deps.knex" transaction.
 export async function handleSending(
@@ -143,7 +144,8 @@ async function handleCompleted(
 export async function sendWebhookEvent(
   deps: ServiceDependencies,
   payment: OutgoingPayment,
-  type: OutgoingPaymentEventType
+  type: OutgoingPaymentEventType,
+  trx?: TransactionOrKnex
 ): Promise<void> {
   // TigerBeetle accounts are only created as the OutgoingPayment is funded.
   // So default the amountSent and balance to 0 for outgoing payments still in the funding state
@@ -168,7 +170,7 @@ export async function sendWebhookEvent(
       }
     : undefined
 
-  await OutgoingPaymentEvent.query(deps.knex).insert({
+  await OutgoingPaymentEvent.query(trx || deps.knex).insert({
     outgoingPaymentId: payment.id,
     type,
     data: payment.toData({ amountSent, balance }),

packages/backend/src/open_payments/payment/outgoing/routes.test.ts

@@ -7,7 +7,12 @@ import { createTestApp, TestContainer } from '../../../tests/app'
 import { Config, IAppConfig } from '../../../config/app'
 import { IocContract } from '@adonisjs/fold'
 import { initIocContainer } from '../../..'
-import { AppServices, CreateContext, ListContext } from '../../../app'
+import {
+  AppServices,
+  CreateContext,
+  ListContext,
+  ReadContext
+} from '../../../app'
 import { truncateTables } from '../../../tests/tableManager'
 import { createAsset } from '../../../tests/asset'
 import { errorToCode, errorToMessage, OutgoingPaymentError } from './errors'
@@ -122,7 +127,25 @@ describe('Outgoing Payment Routes', (): void => {
       list: (ctx) => outgoingPaymentRoutes.list(ctx),
       urlPath: OutgoingPayment.urlPath
     })
+  })
 
+  describe('get', () => {
+    test('returns 500 for unexpected error', async (): Promise<void> => {
+      jest
+        .spyOn(outgoingPaymentService, 'get')
+        .mockRejectedValueOnce(new Error('unexpected'))
+      const ctx = setupContext<ReadContext>({
+        reqOpts: {},
+        walletAddress
+      })
+      await expect(outgoingPaymentRoutes.get(ctx)).rejects.toMatchObject({
+        status: 500,
+        message: 'Unhandled error when trying to get outgoing payment'
+      })
+    })
+  })
+
+  describe('list', () => {
     test('returns 500 for unexpected error', async (): Promise<void> => {
       jest
         .spyOn(outgoingPaymentService, 'getWalletAddressPage')
@@ -133,7 +156,7 @@ describe('Outgoing Payment Routes', (): void => {
       })
       await expect(outgoingPaymentRoutes.list(ctx)).rejects.toMatchObject({
         status: 500,
-        message: `Error trying to list outgoing payments`
+        message: 'Unhandled error when trying to list outgoing payments'
       })
     })
   })
@@ -242,5 +265,24 @@ describe('Outgoing Payment Routes', (): void => {
         })
       }
     )
+
+    test('returns 500 on unhandled error', async (): Promise<void> => {
+      const quoteId = uuid()
+      const ctx = setup({
+        quoteId: `${baseUrl}/quotes/${quoteId}`
+      })
+      const createSpy = jest
+        .spyOn(outgoingPaymentService, 'create')
+        .mockRejectedValueOnce(new Error('Some error'))
+
+      await expect(outgoingPaymentRoutes.create(ctx)).rejects.toMatchObject({
+        message: 'Unhandled error when trying to create outgoing payment',
+        status: 500
+      })
+      expect(createSpy).toHaveBeenCalledWith({
+        walletAddressId: walletAddress.id,
+        quoteId
+      })
+    })
   })
 })

packages/backend/src/open_payments/payment/outgoing/routes.ts

@@ -3,7 +3,12 @@ import { Logger } from 'pino'
 import { ReadContext, CreateContext, ListContext } from '../../../app'
 import { IAppConfig } from '../../../config/app'
 import { OutgoingPaymentService } from './service'
-import { isOutgoingPaymentError, errorToCode, errorToMessage } from './errors'
+import {
+  isOutgoingPaymentError,
+  errorToCode,
+  errorToMessage,
+  OutgoingPaymentError
+} from './errors'
 import { OutgoingPayment } from './model'
 import { listSubresource } from '../../wallet_address/routes'
 import {
@@ -49,8 +54,13 @@ async function getOutgoingPayment(
       id: ctx.params.id,
       client: ctx.accessAction === AccessAction.Read ? ctx.client : undefined
     })
-  } catch (_) {
-    ctx.throw(500, 'Error trying to get outgoing payment')
+  } catch (err) {
+    const errorMessage = 'Unhandled error when trying to get outgoing payment'
+    deps.logger.error(
+      { err, id: ctx.params.id, walletAddressId: ctx.walletAddress.id },
+      errorMessage
+    )
+    return ctx.throw(500, errorMessage)
   }
   if (!outgoingPayment || !outgoingPayment.walletAddress) return ctx.throw(404)
   ctx.body = outgoingPaymentToBody(
@@ -77,19 +87,34 @@ async function createOutgoingPayment(
     return ctx.throw(400, 'invalid quoteId')
   }
 
-  const paymentOrErr = await deps.outgoingPaymentService.create({
-    walletAddressId: ctx.walletAddress.id,
-    quoteId,
-    metadata: body.metadata,
-    client: ctx.client,
-    grant: ctx.grant
-  })
+  let outgoingPaymentOrError: OutgoingPayment | OutgoingPaymentError
 
-  if (isOutgoingPaymentError(paymentOrErr)) {
-    return ctx.throw(errorToCode[paymentOrErr], errorToMessage[paymentOrErr])
+  try {
+    outgoingPaymentOrError = await deps.outgoingPaymentService.create({
+      walletAddressId: ctx.walletAddress.id,
+      quoteId,
+      metadata: body.metadata,
+      client: ctx.client,
+      grant: ctx.grant
+    })
+  } catch (err) {
+    const errorMessage =
+      'Unhandled error when trying to create outgoing payment'
+    deps.logger.error(
+      { err, quoteId, walletAddressId: ctx.walletAddress.id },
+      errorMessage
+    )
+    return ctx.throw(500, errorMessage)
+  }
+
+  if (isOutgoingPaymentError(outgoingPaymentOrError)) {
+    return ctx.throw(
+      errorToCode[outgoingPaymentOrError],
+      errorToMessage[outgoingPaymentOrError]
+    )
   }
   ctx.status = 201
-  ctx.body = outgoingPaymentToBody(ctx.walletAddress, paymentOrErr)
+  ctx.body = outgoingPaymentToBody(ctx.walletAddress, outgoingPaymentOrError)
 }
 
 async function listOutgoingPayments(
@@ -106,7 +131,17 @@ async function listOutgoingPayments(
     if (err instanceof Koa.HttpError) {
       throw err
     }
-    ctx.throw(500, 'Error trying to list outgoing payments')
+
+    const errorMessage = 'Unhandled error when trying to list outgoing payments'
+    deps.logger.error(
+      {
+        err,
+        request: ctx.request.query,
+        walletAddressId: ctx.walletAddress.id
+      },
+      errorMessage
+    )
+    return ctx.throw(500, errorMessage)
   }
 }
 

packages/backend/src/open_payments/payment/outgoing/service.test.ts

@@ -292,6 +292,86 @@ describe('OutgoingPaymentService', (): void => {
     })
   })
 
+  describe('get', (): void => {
+    test('throws error if cannot find liquidity account for SENDING payment', async () => {
+      const quote = await createQuote(deps, {
+        walletAddressId,
+        receiver,
+        debitAmount,
+        method: 'ilp'
+      })
+
+      const payment = await outgoingPaymentService.create({
+        walletAddressId,
+        quoteId: quote.id
+      })
+      assert.ok(!isOutgoingPaymentError(payment))
+
+      await expect(
+        outgoingPaymentService.get({
+          id: payment.id
+        })
+      ).resolves.toEqual(payment)
+      await expect(
+        outgoingPaymentService.fund({
+          id: payment.id,
+          amount: payment.debitAmount.value,
+          transferId: uuid()
+        })
+      ).resolves.toBeDefined()
+      jest
+        .spyOn(accountingService, 'getTotalSent')
+        .mockResolvedValueOnce(undefined)
+      await expect(
+        outgoingPaymentService.get({
+          id: payment.id
+        })
+      ).rejects.toThrow(
+        'Could not get amount sent for payment. There was a problem getting the associated liquidity account.'
+      )
+    })
+  })
+
+  describe('getWalletAddressPage', (): void => {
+    test('throws error if cannot find liquidity account for SENDING payment', async () => {
+      const quote = await createQuote(deps, {
+        walletAddressId,
+        receiver,
+        debitAmount,
+        method: 'ilp'
+      })
+
+      const payment = await outgoingPaymentService.create({
+        walletAddressId,
+        quoteId: quote.id
+      })
+      assert.ok(!isOutgoingPaymentError(payment))
+
+      await expect(
+        outgoingPaymentService.get({
+          id: payment.id
+        })
+      ).resolves.toEqual(payment)
+      await expect(
+        outgoingPaymentService.fund({
+          id: payment.id,
+          amount: payment.debitAmount.value,
+          transferId: uuid()
+        })
+      ).resolves.toBeDefined()
+      jest
+        .spyOn(accountingService, 'getAccountsTotalSent')
+        .mockResolvedValueOnce([undefined])
+      await expect(
+        outgoingPaymentService.getWalletAddressPage({
+          walletAddressId: walletAddressId
+        })
+      ).rejects.toThrow(
+        'Could not get amount sent for payment. There was a problem getting the associated liquidity account.'
+      )
+    })
+  })
+
   describe('create', (): void => {
     enum GrantOption {
       Existing = 'existing',