feat(point-of-sale): pos service API for getting incoming payments (#3708)

* feat(point-of-sale): API for getting pos service's incoming payments

* fix: tests

* feat: filter out unnecessary fields in response

* chore: bruno collection urls

* feat: include senderWalletAddress in query

* fix: bruno urls

* fix: serialize query params properly for gql requests

* fix: expose tenant id in payment gql requests

* feat: use open payments-esque response format

* feat: include metadata

* feat: remove unnecessary fields

* fix: regenerate gql

* fix: imports

* fix: proper object assign use and pr comments

Author: njlie

.eslintrc.yml

@@ -18,7 +18,7 @@ parserOptions:
 plugins:
   - '@typescript-eslint'
 rules:
-  '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }]
+  '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }]
 overrides:
   - files: ["*.js"]
     rules:

bruno/collections/Rafiki/POS Service APIs/Get Incoming Payments.bru

@@ -0,0 +1,15 @@
+meta {
+  name: Get Incoming Payments
+  type: http
+  seq: 4
+}
+
+get {
+  url: http://localhost:4008/payments?receiverWalletAddress=https://happy-life-bank-backend/accounts/pfry
+  body: none
+  auth: inherit
+}
+
+params:query {
+  receiverWalletAddress: https://happy-life-bank-backend/accounts/pfry
+}

packages/backend/src/graphql/resolvers/incoming_payment.ts

@@ -234,6 +234,7 @@ export function paymentToGraphql(
     receivedAmount: payment.receivedAmount,
     metadata: payment.metadata,
     createdAt: new Date(+payment.createdAt).toISOString(),
-    senderWalletAddress: payment.senderWalletAddress
+    senderWalletAddress: payment.senderWalletAddress,
+    tenantId: payment.tenantId
   }
 }

packages/point-of-sale/src/app.ts

@@ -6,8 +6,11 @@ import Koa, { DefaultState } from 'koa'
 import Router from '@koa/router'
 import bodyParser from 'koa-bodyparser'
 import cors from '@koa/cors'
-
-import { PaymentContext, PaymentRoutes } from './payments/routes'
+import {
+  GetPaymentsContext,
+  PaymentContext,
+  PaymentRoutes
+} from './payments/routes'
 import {
   HandleWebhookContext,
   WebhookHandlerRoutes
@@ -65,6 +68,14 @@ export class App {
     const webhookHandlerRoutes = await this.container.use(
       'webhookHandlerRoutes'
     )
+
+    // GET /payments
+    // Get payments made to a given device
+    router.get<DefaultState, GetPaymentsContext>(
+      '/payments',
+      paymentRoutes.getPayments
+    )
+
     // POST /payment
     // Initiate a payment
     router.post<DefaultState, PaymentContext>('/payment', paymentRoutes.payment)

packages/point-of-sale/src/graphql/generated/graphql.ts

@@ -0,0 +1,53 @@
+import { gql } from '@apollo/client/core'
+
+export const GET_WALLET_ADDRESS_BY_URL = gql`
+  query GetWalletAddress(
+    $url: String!
+    $first: Int
+    $last: Int
+    $before: String
+    $after: String
+    $sortOrder: SortOrder
+  ) {
+    walletAddressByUrl(url: $url) {
+      id
+      incomingPayments(
+        first: $first
+        last: $last
+        before: $before
+        after: $after
+        sortOrder: $sortOrder
+      ) {
+        edges {
+          node {
+            id
+            url
+            walletAddressId
+            senderWalletAddress
+            state
+            metadata
+            incomingAmount {
+              assetCode
+              assetScale
+              value
+            }
+            receivedAmount {
+              assetCode
+              assetScale
+              value
+            }
+            expiresAt
+            createdAt
+          }
+          cursor
+        }
+        pageInfo {
+          endCursor
+          hasNextPage
+          hasPreviousPage
+          startCursor
+        }
+      }
+    }
+  }
+`

packages/point-of-sale/src/graphql/queries/getWalletAddress.ts

@@ -4,14 +4,15 @@ import { initIocContainer } from '..'
 import { AppServices } from '../app'
 import { Config, IAppConfig } from '../config/app'
 import { TestContainer, createTestApp } from '../tests/app'
-import { PaymentContext, PaymentRoutes } from './routes'
+import { GetPaymentsContext, PaymentContext, PaymentRoutes } from './routes'
 import { PaymentService } from './service'
 import { CardServiceClient, Result } from '../card-service-client/client'
 import { createContext } from '../tests/context'
 import { CardServiceClientError } from '../card-service-client/errors'
 import { webhookWaitMap } from '../webhook-handlers/request-map'
 import { faker } from '@faker-js/faker'
 import { withConfigOverride } from '../tests/helpers'
+import { IncomingPaymentState } from '../graphql/generated/graphql'
 
 describe('Payment Routes', () => {
   let deps: IocContract<AppServices>
@@ -21,6 +22,24 @@ describe('Payment Routes', () => {
   let cardServiceClient: CardServiceClient
   let config: IAppConfig
 
+  function mockPaymentService() {
+    jest.spyOn(paymentService, 'getWalletAddress').mockResolvedValueOnce({
+      id: 'id',
+      assetCode: 'USD',
+      assetScale: 1,
+      authServer: 'authServer',
+      resourceServer: 'resourceServer',
+      cardService: 'cardService'
+    })
+    jest.spyOn(paymentService, 'createIncomingPayment').mockResolvedValueOnce({
+      id: 'incoming-payment-url',
+      url: faker.internet.url()
+    })
+    jest
+      .spyOn(paymentService, 'getWalletAddressIdByUrl')
+      .mockResolvedValueOnce(faker.internet.url())
+  }
+
   beforeAll(async () => {
     deps = initIocContainer(Config)
     appContainer = await createTestApp(deps)
@@ -135,26 +154,94 @@ describe('Payment Routes', () => {
         }
       )
     )
+  })
 
-    function mockPaymentService() {
-      jest.spyOn(paymentService, 'getWalletAddress').mockResolvedValueOnce({
-        id: 'id',
-        assetCode: 'USD',
-        assetScale: 1,
-        authServer: 'authServer',
-        resourceServer: 'resourceServer',
-        cardService: 'cardService'
-      })
+  describe('get incoming payments', (): void => {
+    test('can get incoming payments for pos device', async (): Promise<void> => {
+      const walletAddressId = v4()
+      const mockServiceResponse = {
+        edges: [
+          {
+            node: {
+              __typename: 'IncomingPayment' as const,
+              id: v4(),
+              url: faker.internet.url(),
+              walletAddressId,
+              client: faker.internet.url(),
+              state: IncomingPaymentState.Pending,
+              incomingAmount: {
+                __typename: 'Amount' as const,
+                value: BigInt(500),
+                assetCode: 'USD',
+                assetScale: 2
+              },
+              receivedAmount: {
+                __typename: 'Amount' as const,
+                value: BigInt(500),
+                assetCode: 'USD',
+                assetScale: 2
+              },
+              expiresAt: new Date().toString(),
+              createdAt: new Date().toString(),
+              tenantId: v4()
+            },
+            cursor: walletAddressId
+          }
+        ],
+        pageInfo: {
+          endCursor: walletAddressId,
+          hasNextPage: false,
+          hasPreviousPage: false,
+          startCursor: walletAddressId
+        }
+      }
       jest
-        .spyOn(paymentService, 'createIncomingPayment')
-        .mockResolvedValueOnce({
-          id: 'incoming-payment-url',
-          url: faker.internet.url()
-        })
+        .spyOn(paymentService, 'getIncomingPayments')
+        .mockResolvedValue(mockServiceResponse)
+      const ctx = createGetPaymentsContext()
+
+      await paymentRoutes.getPayments(ctx)
+      expect(ctx.status).toEqual(200)
+      expect(ctx.body).toEqual({
+        // Ensure that typename is sanitized
+        result: mockServiceResponse.edges.map((edge) => {
+          const {
+            __typename: _nodeTypename,
+            receivedAmount,
+            incomingAmount,
+            ...restOfNode
+          } = edge.node
+          const { __typename: _receivedTypename, ...restOfReceived } =
+            receivedAmount
+          const { __typename: _incomingTypename, ...restOfIncoming } =
+            incomingAmount
+          return {
+            ...restOfNode,
+            incomingAmount: restOfIncoming,
+            receivedAmount: restOfReceived
+          }
+        }),
+        pagination: mockServiceResponse.pageInfo
+      })
+    })
+
+    test('returns empty page if no incoming payments', async (): Promise<void> => {
       jest
-        .spyOn(paymentService, 'getWalletAddressIdByUrl')
-        .mockResolvedValueOnce(faker.internet.url())
-    }
+        .spyOn(paymentService, 'getIncomingPayments')
+        .mockResolvedValue(undefined)
+
+      const ctx = createGetPaymentsContext()
+
+      await paymentRoutes.getPayments(ctx)
+      expect(ctx.status).toEqual(200)
+      expect(ctx.body).toMatchObject({
+        result: [],
+        pagination: {
+          hasNextPage: false,
+          hasPreviousPage: false
+        }
+      })
+    })
   })
 })
 
@@ -173,3 +260,14 @@ function createPaymentContext() {
     }
   })
 }
+
+function createGetPaymentsContext() {
+  return createContext<GetPaymentsContext>({
+    headers: { Accept: 'application/json' },
+    method: 'GET',
+    url: `/payments`,
+    query: {
+      receiverWalletAddress: faker.internet.url()
+    }
+  })
+}