@defra-fish/sales-api-service 1.77.0-rc.9 → 1.78.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/sales-api-service",
-  "version": "1.77.0-rc.9",
+  "version": "1.78.0-rc.0",
   "description": "Rod Licensing Sales API",
   "type": "module",
   "engines": {
@@ -35,9 +35,9 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@defra-fish/business-rules-lib": "1.77.0-rc.9",
-    "@defra-fish/connectors-lib": "1.77.0-rc.9",
-    "@defra-fish/dynamics-lib": "1.77.0-rc.9",
+    "@defra-fish/business-rules-lib": "1.78.0-rc.0",
+    "@defra-fish/connectors-lib": "1.78.0-rc.0",
+    "@defra-fish/dynamics-lib": "1.78.0-rc.0",
     "@hapi/boom": "9.1.2",
     "@hapi/hapi": "20.1.3",
     "@hapi/inert": "6.0.3",
@@ -53,5 +53,5 @@
     "moment-timezone": "0.5.34",
     "uuid": "8.3.2"
   },
-  "gitHead": "3cfd7fe39ca9db0267159d64702dab54ad183be1"
+  "gitHead": "ba58b90ce215474827f38d37d844937adf10f2e6"
 }

package/src/services/transactions/__tests__/process-transaction-queue.spec.js

@@ -1,3 +1,4 @@
+import db from 'debug'
 import { processQueue, getTransactionJournalRefNumber } from '../process-transaction-queue.js'
 import {
   persist,
@@ -27,8 +28,12 @@ import {
   generateRecurringPaymentRecord,
   findNewestExistingRecurringPaymentInCrm
 } from '../../recurring-payments.service.js'
+import { retrieveStagedTransaction } from '../retrieve-transaction.js'
 import { AWS } from '@defra-fish/connectors-lib'
 const { docClient } = AWS.mock.results[0].value
+const { value: debug } = db.mock.results[db.mock.calls.findIndex(c => c[0] === 'sales:transactions')]
+
+jest.mock('debug', () => jest.fn(() => jest.fn()))
 
 jest.mock('../../reference-data.service.js', () => ({
   ...jest.requireActual('../../reference-data.service.js'),
@@ -72,6 +77,10 @@ jest.mock('../../recurring-payments.service.js', () => ({
   processRecurringPayment: jest.fn()
 }))
 
+jest.mock('../retrieve-transaction.js', () => ({
+  retrieveStagedTransaction: jest.fn()
+}))
+
 jest.mock('@defra-fish/connectors-lib', () => {
   const mockAWS = {
     docClient: {
@@ -204,17 +213,11 @@ describe('transaction service', () => {
         ]
       ])('handles %s', async (description, initialiseMockTransactionRecord, entityExpectations) => {
         const mockRecord = initialiseMockTransactionRecord()
-        docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
         const result = await processQueue({ id: mockRecord.id })
         expect(result).toBeUndefined()
         expect(persist).toBeCalledWith(entityExpectations, undefined)
-        expect(docClient.get).toHaveBeenCalledWith(
-          expect.objectContaining({
-            TableName: TRANSACTION_STAGING_TABLE.TableName,
-            Key: { id: mockRecord.id },
-            ConsistentRead: true
-          })
-        )
+        expect(retrieveStagedTransaction).toHaveBeenCalledWith(mockRecord.id)
         expect(docClient.delete).toHaveBeenCalledWith(
           expect.objectContaining({
             TableName: TRANSACTION_STAGING_TABLE.TableName,
@@ -248,7 +251,7 @@ describe('transaction service', () => {
       it('includes a FulfilmentRequest when the permit and contact are for postal fulfilment', async () => {
         const mockRecord = mockFinalisedTransactionRecord()
         mockRecord.permissions[0].permitId = MOCK_12MONTH_SENIOR_PERMIT.id
-        docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
         await processQueue({ id: mockRecord.id })
         expect(persist).toBeCalledWith(
           [
@@ -267,7 +270,7 @@ describe('transaction service', () => {
       it('does not include a FulfilmentRequest when the permit and contact are not for postal fulfilment', async () => {
         const mockRecord = mockFinalisedTransactionRecord()
         mockRecord.permissions[0].permitId = MOCK_1DAY_SENIOR_PERMIT_ENTITY.id
-        docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
         await processQueue({ id: mockRecord.id })
         expect(persist).toBeCalledWith(
           [
@@ -295,7 +298,7 @@ describe('transaction service', () => {
       it('does not include a FulfilmentRequest when the permit and contact are for postal fulfilment', async () => {
         const mockRecord = mockFinalisedTransactionRecord()
         mockRecord.permissions[0].permitId = MOCK_12MONTH_SENIOR_PERMIT.id
-        docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
         await processQueue({ id: mockRecord.id })
         expect(persist).toBeCalledWith(
           [
@@ -313,7 +316,7 @@ describe('transaction service', () => {
       it('does not include a FulfilmentRequest when the permit and contact are not for postal fulfilment', async () => {
         const mockRecord = mockFinalisedTransactionRecord()
         mockRecord.permissions[0].permitId = MOCK_1DAY_SENIOR_PERMIT_ENTITY.id
-        docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
         await processQueue({ id: mockRecord.id })
         expect(persist).toBeCalledWith(
           [
@@ -332,7 +335,7 @@ describe('transaction service', () => {
     it('sets isLicenceForYou to Yes on the transaction, if it is true on the permission', async () => {
       const mockRecord = mockFinalisedTransactionRecord()
       mockRecord.permissions[0].isLicenceForYou = true
-      docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+      retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
       await processQueue({ id: mockRecord.id })
       const persistMockFirstAgument = persist.mock.calls[0]
       expect(persistMockFirstAgument[0][4].isLicenceForYou).toBeDefined()
@@ -342,7 +345,7 @@ describe('transaction service', () => {
     it('sets isLicenceForYou to No on the transaction, if it is false on the permission', async () => {
       const mockRecord = mockFinalisedTransactionRecord()
       mockRecord.permissions[0].isLicenceForYou = false
-      docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+      retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
       await processQueue({ id: mockRecord.id })
       const persistMockFirstAgument = persist.mock.calls[0]
       expect(persistMockFirstAgument[0][4].isLicenceForYou).toBeDefined()
@@ -352,7 +355,7 @@ describe('transaction service', () => {
     it('does not set isLicenceForYou on the transaction, if it is undefined on the permission', async () => {
       const mockRecord = mockFinalisedTransactionRecord()
       mockRecord.permissions[0].isLicenceForYou = undefined
-      docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+      retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
       await processQueue({ id: mockRecord.id })
       const persistMockFirstAgument = persist.mock.calls[0]
       expect(persistMockFirstAgument[0][4].isLicenceForYou).toBeUndefined()
@@ -361,7 +364,7 @@ describe('transaction service', () => {
     it('does not set isLicenceForYou on the transaction, if it is null on the permission', async () => {
       const mockRecord = mockFinalisedTransactionRecord()
       mockRecord.permissions[0].isLicenceForYou = null
-      docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+      retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
       await processQueue({ id: mockRecord.id })
       const persistMockFirstAgument = persist.mock.calls[0]
       expect(persistMockFirstAgument[0][4].isLicenceForYou).toBeUndefined()
@@ -371,7 +374,7 @@ describe('transaction service', () => {
       const transactionFilename = 'test-file.xml'
       const mockRecord = mockFinalisedTransactionRecord()
       mockRecord.transactionFile = transactionFilename
-      docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+      retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
       const transactionToFileBindingSpy = jest.spyOn(Transaction.prototype, 'bindToAlternateKey')
       const permissionToFileBindingSpy = jest.spyOn(Permission.prototype, 'bindToAlternateKey')
       await processQueue({ id: mockRecord.id })
@@ -379,22 +382,141 @@ describe('transaction service', () => {
       expect(permissionToFileBindingSpy).toHaveBeenCalledWith(Permission.definition.relationships.poclFile, transactionFilename)
     })
 
-    it('throws 404 not found error if a record cannot be found for the given id', async () => {
-      const mockRecord = mockFinalisedTransactionRecord()
-      docClient.get.mockResolvedValueOnce({ Item: undefined }).mockResolvedValueOnce({ Item: undefined })
-      try {
-        await processQueue({ id: mockRecord.id })
-      } catch (e) {
-        expect(e.message).toEqual('A transaction for the specified identifier was not found')
-        expect(e.output.statusCode).toEqual(404)
+    it('throws an error if retrieveStagedTransaction fails', async () => {
+      const error = new Error('Boo!')
+      retrieveStagedTransaction.mockRejectedValueOnce(error)
+
+      await expect(processQueue({ id: 'foo' })).rejects.toThrow(error)
+    })
+
+    describe('when persisting throws an error', () => {
+      it('throws the error', async () => {
+        const transactionFilename = 'test-file.xml'
+        const mockRecord = mockFinalisedTransactionRecord()
+        mockRecord.transactionFile = transactionFilename
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
+
+        const error = new Error('I do not like it')
+        persist.mockRejectedValueOnce(error)
+
+        await expect(processQueue({ id: mockRecord.id })).rejects.toThrow(error)
+      })
+
+      it('does not delete the data from the transaction staging table', async () => {
+        const transactionFilename = 'test-file.xml'
+        const mockRecord = mockFinalisedTransactionRecord()
+        mockRecord.transactionFile = transactionFilename
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
+
+        const error = new Error('I do not like it')
+        persist.mockRejectedValueOnce(error)
+
+        try {
+          await processQueue({ id: mockRecord.id })
+        } catch (e) {}
+
+        expect(docClient.delete).not.toHaveBeenCalled()
+      })
+
+      it('does not move the data to the transaction staging history table', async () => {
+        const transactionFilename = 'test-file.xml'
+        const mockRecord = mockFinalisedTransactionRecord()
+        mockRecord.transactionFile = transactionFilename
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
+
+        const error = new Error('I do not like it')
+        persist.mockRejectedValueOnce(error)
+
+        try {
+          await processQueue({ id: mockRecord.id })
+        } catch (e) {}
+
+        expect(docClient.put).not.toHaveBeenCalled()
+      })
+    })
+
+    describe('when persisting throws an PermissionReferenceNumber_Key error', () => {
+      const permissionReferenceKeyError = () => {
+        const e = new Error()
+        e.error = {
+          message:
+            'Entity Key PermissionReferenceNumber_Key violated. A record with the same value for Permission Reference Number already exists. A duplicate record cannot be created. Select one or more unique values and try again.'
+        }
+        return e
       }
+
+      it('does not throw an error', async () => {
+        const transactionFilename = 'test-file.xml'
+        const mockRecord = mockFinalisedTransactionRecord()
+        mockRecord.transactionFile = transactionFilename
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
+
+        persist.mockRejectedValueOnce(permissionReferenceKeyError())
+
+        await expect(processQueue({ id: mockRecord.id })).resolves.not.toThrow()
+      })
+
+      it('logs that the permission has already been persisted', async () => {
+        const transactionFilename = 'test-file.xml'
+        const mockRecord = mockFinalisedTransactionRecord()
+        mockRecord.transactionFile = transactionFilename
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
+
+        persist.mockRejectedValueOnce(permissionReferenceKeyError())
+
+        await processQueue({ id: mockRecord.id })
+
+        expect(debug).toHaveBeenCalledWith('Permission for staging id %s has already been persisted', mockRecord.id)
+      })
+
+      it('deletes the data from the transaction staging table', async () => {
+        const transactionFilename = 'test-file.xml'
+        const mockRecord = mockFinalisedTransactionRecord()
+        mockRecord.transactionFile = transactionFilename
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
+
+        persist.mockRejectedValueOnce(permissionReferenceKeyError())
+
+        await processQueue({ id: mockRecord.id })
+
+        expect(docClient.delete).toHaveBeenCalledWith(
+          expect.objectContaining({
+            TableName: TRANSACTION_STAGING_TABLE.TableName,
+            Key: { id: mockRecord.id }
+          })
+        )
+      })
+
+      it('moves the data to the transaction staging history table', async () => {
+        const transactionFilename = 'test-file.xml'
+        const mockRecord = mockFinalisedTransactionRecord()
+        mockRecord.transactionFile = transactionFilename
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
+
+        persist.mockRejectedValueOnce(permissionReferenceKeyError())
+
+        await processQueue({ id: mockRecord.id })
+
+        const expectedRecord = Object.assign(mockRecord, {
+          id: expect.stringMatching(/[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}/i),
+          expires: expect.any(Number)
+        })
+
+        expect(docClient.put).toHaveBeenCalledWith(
+          expect.objectContaining({
+            TableName: TRANSACTION_STAGING_HISTORY_TABLE.TableName,
+            Item: expectedRecord,
+            ConditionExpression: 'attribute_not_exists(id)'
+          })
+        )
+      })
     })
 
     describe.each([20, 38.46, 287])('the provisional transaction amount of £%d is used for final transaction amount', cost => {
       const setup = async () => {
         const mockRecord = mockFinalisedTransactionRecord()
         mockRecord.payment.amount = cost
-        docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
         await processQueue({ id: mockRecord.id })
         const {
           mock: {
@@ -427,7 +549,7 @@ describe('transaction service', () => {
           callingArgs.transaction = JSON.parse(JSON.stringify(transaction))
         })
         const mockRecord = mockFinalisedTransactionRecord()
-        docClient.get.mockResolvedValueOnce({ Item: { ...mockRecord } })
+        retrieveStagedTransaction.mockResolvedValueOnce({ ...mockRecord })
         await processQueue({ id: mockRecord.id })
         // jest.fn args aren't immutable and transaction is changed in processQueue, so we use our clone that hasn't changed
         expect(callingArgs.transaction).toEqual(mockRecord)
@@ -440,7 +562,7 @@ describe('transaction service', () => {
         for (const key of keysToCopy) {
           expectedPermissionData[key] = mockRecord.permissions[0][key]
         }
-        docClient.get.mockResolvedValueOnce({ Item: mockRecord })
+        retrieveStagedTransaction.mockResolvedValueOnce(mockRecord)
 
         await processQueue({ id: mockRecord.id })
 
@@ -451,7 +573,7 @@ describe('transaction service', () => {
         const rprSymbol = Symbol('rpr')
         const finalisedTransaction = mockFinalisedTransactionRecord()
         generateRecurringPaymentRecord.mockReturnValueOnce(rprSymbol)
-        docClient.get.mockResolvedValueOnce({ Item: finalisedTransaction })
+        retrieveStagedTransaction.mockResolvedValueOnce(finalisedTransaction)
         await processQueue({ id: finalisedTransaction.id })
         expect(processRecurringPayment).toHaveBeenCalledWith(rprSymbol, expect.any(Contact))
       })
@@ -464,7 +586,7 @@ describe('transaction service', () => {
         const finalisedTransaction = mockFinalisedTransactionRecord()
         findNewestExistingRecurringPaymentInCrm.mockReturnValueOnce(mockExistingRecurringPayment)
         processRecurringPayment.mockReturnValueOnce({ recurringPayment: mockNewRecurringPayment })
-        docClient.get.mockResolvedValueOnce({ Item: finalisedTransaction })
+        retrieveStagedTransaction.mockResolvedValueOnce(finalisedTransaction)
         await processQueue({ id: finalisedTransaction.id })
         expect(mockExistingRecurringPayment.bindToEntity).toHaveBeenCalledWith(
           RecurringPayment.definition.relationships.nextRecurringPayment,

package/src/services/transactions/__tests__/retrieve-transaction.spec.js

@@ -0,0 +1,100 @@
+import Boom from '@hapi/boom'
+import db from 'debug'
+import { retrieveStagedTransaction } from '../retrieve-transaction.js'
+import { TRANSACTION_STAGING_TABLE, TRANSACTION_STAGING_HISTORY_TABLE } from '../../../config.js'
+import { AWS } from '@defra-fish/connectors-lib'
+const { docClient } = AWS.mock.results[0].value
+const { value: debug } = db.mock.results[db.mock.calls.findIndex(c => c[0] === 'sales:transactions')]
+
+jest.mock('debug', () => jest.fn(() => jest.fn()))
+
+jest.mock('@defra-fish/connectors-lib', () => {
+  const mockAWS = {
+    docClient: {
+      get: jest.fn()
+    }
+  }
+  return {
+    AWS: jest.fn(() => mockAWS)
+  }
+})
+
+const mockResultWithItem = (item = 'foo') => ({
+  Item: item
+})
+
+describe('retrieve-transaction', () => {
+  it('checks the staging table for a match', async () => {
+    const id = 'foo'
+    docClient.get.mockResolvedValueOnce(mockResultWithItem())
+
+    await retrieveStagedTransaction(id)
+
+    expect(docClient.get).toHaveBeenCalledWith({ TableName: TRANSACTION_STAGING_TABLE.TableName, Key: { id }, ConsistentRead: true })
+  })
+
+  describe('when the result has an item', () => {
+    it('logs that it has retrieved a record', async () => {
+      const id = 'foo'
+      docClient.get.mockResolvedValueOnce(mockResultWithItem())
+
+      await retrieveStagedTransaction(id)
+
+      expect(debug).toHaveBeenCalledWith('Retrieved transaction record for staging id %s', id)
+    })
+
+    it('returns the result item', async () => {
+      const expectedItem = Symbol('Item')
+      docClient.get.mockResolvedValueOnce(mockResultWithItem(expectedItem))
+
+      const transactionResult = await retrieveStagedTransaction('foo')
+
+      expect(transactionResult).toEqual(expectedItem)
+    })
+  })
+
+  describe('when the result does not have an item', () => {
+    it('logs that it has failed to retrieve a record', async () => {
+      const id = 'foo'
+      docClient.get.mockResolvedValueOnce({}).mockResolvedValueOnce(mockResultWithItem())
+
+      try {
+        await retrieveStagedTransaction(id)
+      } catch {
+        expect(debug).toHaveBeenCalledWith('Failed to retrieve a transaction with staging id %s', id)
+      }
+    })
+
+    it('checks the historical staging table for a match', async () => {
+      const id = 'foo'
+      docClient.get.mockResolvedValueOnce({}).mockResolvedValueOnce(mockResultWithItem())
+
+      try {
+        await retrieveStagedTransaction(id)
+      } catch {
+        expect(docClient.get).toHaveBeenCalledWith({
+          TableName: TRANSACTION_STAGING_HISTORY_TABLE.TableName,
+          Key: { id },
+          ConsistentRead: true
+        })
+      }
+    })
+
+    it('throws a 410 Gone error if there is not a historical match', async () => {
+      const historicalItem = Symbol('historicalItem')
+      docClient.get.mockResolvedValueOnce({}).mockResolvedValueOnce(mockResultWithItem(historicalItem))
+
+      await expect(retrieveStagedTransaction('foo')).rejects.toThrow(
+        Boom.resourceGone('The transaction has already been finalised', historicalItem)
+      )
+    })
+
+    it('throws a 404 Not Found error if there is not a historical match', async () => {
+      docClient.get.mockResolvedValueOnce({}).mockResolvedValueOnce({})
+
+      await expect(retrieveStagedTransaction('foo')).rejects.toThrow(
+        Boom.notFound('A transaction for the specified identifier was not found')
+      )
+    })
+  })
+})

package/src/services/transactions/process-transaction-queue.js

@@ -102,7 +102,9 @@ export async function processQueue ({ id }) {
   paymentJournal.total = totalTransactionValue
 
   debug('Persisting %d entities for staging id %s', entities.length, id)
-  await persist(entities, transactionRecord.createdBy)
+
+  await persistEntities(entities, transactionRecord, id)
+
   debug('Moving staging data to history table for staging id %s', id)
   await docClient.delete({ TableName: TRANSACTION_STAGING_TABLE.TableName, Key: { id } })
   await docClient.put({
@@ -172,6 +174,20 @@ const createTransactionEntities = async transactionRecord => {
   return { transaction, chargeJournal, paymentJournal }
 }
 
+const persistEntities = async (entities, transactionRecord, id) => {
+  const ALREADY_PERSISTED_ERROR = /Permission Reference Number already exists/
+
+  try {
+    await persist(entities, transactionRecord.createdBy)
+  } catch (e) {
+    if (e?.error?.message.match(ALREADY_PERSISTED_ERROR)) {
+      debug('Permission for staging id %s has already been persisted', id)
+    } else {
+      throw e
+    }
+  }
+}
+
 export const getTransactionJournalRefNumber = (transactionRecord, type) => {
   if (POCL_TRANSACTION_SOURCES.includes(transactionRecord.dataSource) && type === 'Payment') {
     if (transactionRecord.dataSource === DDE_DATA_SOURCE && transactionRecord.journalId) {