@defra-fish/sales-api-service 1.61.0-rc.16 → 1.61.0-rc.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/sales-api-service",
-  "version": "1.61.0-rc.16",
+  "version": "1.61.0-rc.18",
   "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.61.0-rc.16",
-    "@defra-fish/connectors-lib": "1.61.0-rc.16",
-    "@defra-fish/dynamics-lib": "1.61.0-rc.16",
+    "@defra-fish/business-rules-lib": "1.61.0-rc.18",
+    "@defra-fish/connectors-lib": "1.61.0-rc.18",
+    "@defra-fish/dynamics-lib": "1.61.0-rc.18",
     "@hapi/boom": "^9.1.2",
     "@hapi/hapi": "^20.1.3",
     "@hapi/inert": "^6.0.3",
@@ -52,5 +52,5 @@
     "moment-timezone": "^0.5.34",
     "uuid": "^8.3.2"
   },
-  "gitHead": "a4d24d55c8279ed8fad6436a48312f8542adfada"
+  "gitHead": "e6a140250c115a25e37da3f1639e83df2e6ca886"
 }

package/src/schema/__tests__/recurring-payments.schema.spec.js

@@ -1,8 +1,7 @@
 import {
   dueRecurringPaymentsRequestParamsSchema,
   dueRecurringPaymentsResponseSchema,
-  processRPResultRequestParamsSchema,
-  linkRecurringPaymentsRequestParamsSchema
+  processRPResultRequestParamsSchema
 } from '../recurring-payments.schema.js'
 
 jest.mock('../validators/validators.js', () => ({
@@ -63,11 +62,6 @@ const getProcessRPResultSampleData = () => ({
   createdDate: '2025-01-01T00:00:00.000Z'
 })
 
-const getLinkRecurringPaymentsSampleData = () => ({
-  existingRecurringPaymentId: 'ghi123',
-  agreementId: 'jkl456'
-})
-
 describe('getDueRecurringPaymentsSchema', () => {
   it('validates expected object', async () => {
     expect(() => dueRecurringPaymentsResponseSchema.validateAsync(getResponseSampleData())).not.toThrow()
@@ -155,24 +149,3 @@ describe('processRPResultRequestParamsSchema', () => {
     expect(() => processRPResultRequestParamsSchema.validateAsync(sampleData).rejects.toThrow())
   })
 })
-
-describe('linkRecurringPaymentsRequestParamsSchema', () => {
-  it('validates expected object', async () => {
-    expect(() => linkRecurringPaymentsRequestParamsSchema.validateAsync(getLinkRecurringPaymentsSampleData())).not.toThrow()
-  })
-
-  it.each([['existingRecurringPaymentId'], ['agreementId']])('throws an error if %s is missing', async property => {
-    const sampleData = getLinkRecurringPaymentsSampleData()
-    delete sampleData[property]
-    expect(() => linkRecurringPaymentsRequestParamsSchema.validateAsync(sampleData).rejects.toThrow())
-  })
-
-  it.each([
-    ['existingRecurringPaymentId', 99],
-    ['agreementId', 99]
-  ])('throws an error if %s is not the correct type', async (property, value) => {
-    const sampleData = getLinkRecurringPaymentsSampleData()
-    sampleData[property] = value
-    expect(() => linkRecurringPaymentsRequestParamsSchema.validateAsync(sampleData).rejects.toThrow())
-  })
-})

package/src/schema/recurring-payments.schema.js

@@ -29,8 +29,3 @@ export const processRPResultRequestParamsSchema = Joi.object({
   paymentId: Joi.string().required(),
   createdDate: Joi.string().isoDate().required()
 })
-
-export const linkRecurringPaymentsRequestParamsSchema = Joi.object({
-  existingRecurringPaymentId: Joi.string().required(),
-  agreementId: Joi.string().required()
-})

package/src/server/routes/__tests__/recurring-payments.spec.js

@@ -1,10 +1,6 @@
 import recurringPayments from '../recurring-payments.js'
-import { getRecurringPayments, processRPResult, linkRecurringPayments } from '../../../services/recurring-payments.service.js'
-import {
-  dueRecurringPaymentsRequestParamsSchema,
-  processRPResultRequestParamsSchema,
-  linkRecurringPaymentsRequestParamsSchema
-} from '../../../schema/recurring-payments.schema.js'
+import { getRecurringPayments, processRPResult } from '../../../services/recurring-payments.service.js'
+import { dueRecurringPaymentsRequestParamsSchema, processRPResultRequestParamsSchema } from '../../../schema/recurring-payments.schema.js'
 
 const [
   {
@@ -12,22 +8,17 @@ const [
   },
   {
     options: { handler: prpHandler }
-  },
-  {
-    options: { handler: lrpHandler }
   }
 ] = recurringPayments
 
 jest.mock('../../../services/recurring-payments.service.js', () => ({
   getRecurringPayments: jest.fn(),
-  processRPResult: jest.fn(),
-  linkRecurringPayments: jest.fn()
+  processRPResult: jest.fn()
 }))
 
 jest.mock('../../../schema/recurring-payments.schema.js', () => ({
   dueRecurringPaymentsRequestParamsSchema: jest.fn(),
-  processRPResultRequestParamsSchema: jest.fn(),
-  linkRecurringPaymentsRequestParamsSchema: jest.fn()
+  processRPResultRequestParamsSchema: jest.fn()
 }))
 
 const getMockRequest = ({
@@ -95,28 +86,4 @@ describe('recurring payments', () => {
       expect(recurringPayments[1].options.validate.params).toBe(processRPResultRequestParamsSchema)
     })
   })
-
-  describe('linkRecurringPayments', () => {
-    it('handler should return continue response', async () => {
-      const request = getMockRequest({})
-      const responseToolkit = getMockResponseToolkit()
-      expect(await lrpHandler(request, responseToolkit)).toEqual(responseToolkit.continue)
-    })
-
-    it('should call linkRecurringPayments with existingRecurringPaymentId and agreementId', async () => {
-      const existingRecurringPaymentId = Symbol('existing-recurring-payment')
-      const agreementId = Symbol('agreement-id')
-      const request = getMockRequest({ existingRecurringPaymentId, agreementId })
-      await lrpHandler(request, getMockResponseToolkit())
-      expect(linkRecurringPayments).toHaveBeenCalledWith(existingRecurringPaymentId, agreementId)
-    })
-
-    it('should validate with linkRecurringPaymentsRequestParamsSchema', async () => {
-      const existingRecurringPaymentId = Symbol('existing-recurring-payment')
-      const agreementId = Symbol('agreement-id')
-      const request = getMockRequest({ existingRecurringPaymentId, agreementId })
-      await lrpHandler(request, getMockResponseToolkit())
-      expect(recurringPayments[2].options.validate.params).toBe(linkRecurringPaymentsRequestParamsSchema)
-    })
-  })
 })

package/src/server/routes/recurring-payments.js

@@ -1,10 +1,9 @@
 import {
   dueRecurringPaymentsRequestParamsSchema,
   dueRecurringPaymentsResponseSchema,
-  linkRecurringPaymentsRequestParamsSchema,
   processRPResultRequestParamsSchema
 } from '../../schema/recurring-payments.schema.js'
-import { getRecurringPayments, linkRecurringPayments, processRPResult } from '../../services/recurring-payments.service.js'
+import { getRecurringPayments, processRPResult } from '../../services/recurring-payments.service.js'
 
 const SWAGGER_TAGS = ['api', 'recurring-payments']
 
@@ -56,29 +55,5 @@ export default [
         }
       }
     }
-  },
-  {
-    method: 'GET',
-    path: '/linkRecurringPayments/{existingRecurringPaymentId}/{agreementId}',
-    options: {
-      handler: async (request, h) => {
-        const { existingRecurringPaymentId, agreementId } = request.params
-        const result = await linkRecurringPayments(existingRecurringPaymentId, agreementId)
-        return h.response(result)
-      },
-      description: 'Link an old RecurringPayment to its replacement',
-      tags: SWAGGER_TAGS,
-      validate: {
-        params: linkRecurringPaymentsRequestParamsSchema
-      },
-      plugins: {
-        'hapi-swagger': {
-          responses: {
-            200: { description: 'Old RecurringPayment linked to new RecurringPayment successfully' }
-          },
-          order: 3
-        }
-      }
-    }
   }
 ]

package/src/services/__tests__/recurring-payments.service.spec.js

@@ -1,10 +1,17 @@
-import { executeQuery, findDueRecurringPayments, findRecurringPaymentsByAgreementId, Permission } from '@defra-fish/dynamics-lib'
+import {
+  dynamicsClient,
+  executeQuery,
+  findDueRecurringPayments,
+  findRecurringPaymentsByAgreementId,
+  Permission,
+  RecurringPayment
+} from '@defra-fish/dynamics-lib'
 import {
   getRecurringPayments,
   processRecurringPayment,
   generateRecurringPaymentRecord,
   processRPResult,
-  linkRecurringPayments
+  findNewestExistingRecurringPaymentInCrm
 } from '../recurring-payments.service.js'
 import { calculateEndDate, generatePermissionNumber } from '../permissions.service.js'
 import { getObfuscatedDob } from '../contacts.service.js'
@@ -20,9 +27,11 @@ const { docClient, sqs } = AWS.mock.results[0].value
 jest.mock('@defra-fish/dynamics-lib', () => ({
   ...jest.requireActual('@defra-fish/dynamics-lib'),
   executeQuery: jest.fn(),
-  findById: jest.fn(),
   findDueRecurringPayments: jest.fn(),
-  findRecurringPaymentsByAgreementId: jest.fn(() => ['foo'])
+  findRecurringPaymentsByAgreementId: jest.fn(() => ({ toRetrieveRequest: () => {} })),
+  dynamicsClient: {
+    retrieveMultipleRequest: jest.fn(() => ({ value: [] }))
+  }
 }))
 
 jest.mock('@defra-fish/connectors-lib', () => ({
@@ -80,8 +89,6 @@ jest.mock('@defra-fish/business-rules-lib', () => ({
   }
 }))
 
-const dynamicsLib = jest.requireMock('@defra-fish/dynamics-lib')
-
 const getMockRecurringPayment = (overrides = {}) => ({
   name: 'Test Name',
   nextDueDate: '2019-12-14T00:00:00Z',
@@ -168,6 +175,54 @@ const getMockTransaction = (id = 'test-id') => ({
   ]
 })
 
+const getMockResponse = () => ({
+  '@odata.context': 'https://ea-fish-devsandbox.crm4.dynamics.com/api/data/v9.1/$metadata#defra_recurringpayments',
+  value: [
+    {
+      '@odata.etag': 'W/"183695502"',
+      defra_recurringpaymentid: 'ed8e5dc7-d346-f011-877a-6045bde009c2',
+      defra_name: null,
+      statecode: 1,
+      defra_nextduedate: '2025-06-11T00:00:00Z',
+      defra_cancelleddate: null,
+      defra_cancelledreason: null,
+      defra_enddate: '2025-06-20T22:59:59Z',
+      defra_agreementid: 's6i8q2lcrgqene2s8u1qeaiel6',
+      defra_publicid: 'JIwepr5/XgxwLHF9u20F1veSdWqeMJz/dzVfjPKrflM=',
+      defra_lastdigitscardnumbers: null
+    },
+    {
+      '@odata.etag': 'W/"184173292"',
+      statecode: 1,
+      defra_recurringpaymentid: 'f5011f95-ac47-f011-877a-6045bde009c2',
+      defra_publicid: '/KTtr4kFQvLwSP3Xz/xAxh9jWbGuzW17ALni4rmip4k=',
+      defra_cancelleddate: null,
+      defra_inceptionmonth: null,
+      defra_cancelledreason: null,
+      defra_nextduedate: '2026-06-10T00:00:00Z',
+      defra_last_digits_card_number: null,
+      defra_enddate: '2026-06-20T22:59:59Z',
+      defra_agreementid: 's6i8q2lcrgqene2s8u1qeaiel6',
+      defra_lastdigitscardnumbers: null,
+      defra_name: null
+    },
+    {
+      '@odata.etag': 'W/"184173352"',
+      statecode: 1,
+      defra_recurringpaymentid: '0d021f95-ac47-f011-877a-6045bde009c2',
+      defra_publicid: 'y3vgHMkqiMyp0vyb3rrS9KvqvU+kUl6P4b74X62SFOU=',
+      defra_cancelleddate: null,
+      defra_cancelledreason: null,
+      defra_nextduedate: '2024-06-10T00:00:00Z',
+      defra_last_digits_card_number: null,
+      defra_enddate: '2024-06-20T22:59:59Z',
+      defra_agreementid: 's6i8q2lcrgqene2s8u1qeaiel6',
+      defra_lastdigitscardnumbers: null,
+      defra_name: null
+    }
+  ]
+})
+
 describe('recurring payments service', () => {
   const createSimpleSampleTransactionRecord = () => ({ payment: { recurring: true }, permissions: [{}] })
   const createSamplePermission = overrides => {
@@ -197,7 +252,7 @@ describe('recurring payments service', () => {
       const mockContact = mockRecurringPayments[0].expanded.contact
       const mockPermission = mockRecurringPayments[0].expanded.activePermission
 
-      dynamicsLib.executeQuery.mockResolvedValueOnce(mockRecurringPayments)
+      executeQuery.mockResolvedValueOnce(mockRecurringPayments)
 
       const result = await getRecurringPayments(new Date())
 
@@ -207,11 +262,11 @@ describe('recurring payments service', () => {
     it('executeQuery is called with findDueRecurringPayments with a date', async () => {
       const mockRecurringPayments = [getMockRecurringPayment()]
       const mockDate = new Date()
-      dynamicsLib.executeQuery.mockResolvedValueOnce(mockRecurringPayments)
+      executeQuery.mockResolvedValueOnce(mockRecurringPayments)
 
       await getRecurringPayments(mockDate)
 
-      expect(dynamicsLib.executeQuery).toHaveBeenCalledWith(findDueRecurringPayments(mockDate))
+      expect(executeQuery).toHaveBeenCalledWith(findDueRecurringPayments(mockDate))
     })
   })
 
@@ -616,42 +671,66 @@ describe('recurring payments service', () => {
     })
   })
 
-  describe('linkRecurringPayments', () => {
-    it('should call executeQuery with findRecurringPaymentsByAgreementId and the provided agreementId', async () => {
-      const agreementId = 'abc123'
-      await linkRecurringPayments('existing-recurring-payment-id', agreementId)
-      expect(executeQuery).toHaveBeenCalledWith(findRecurringPaymentsByAgreementId(agreementId))
+  describe('findNewestExistingRecurringPaymentInCrm', () => {
+    it('passes agreement id to findRecurringPaymentsByAgreementId', async () => {
+      const agreementId = Symbol('agreement-id')
+      await findNewestExistingRecurringPaymentInCrm(agreementId)
+      expect(findRecurringPaymentsByAgreementId).toHaveBeenCalledWith(agreementId)
     })
 
-    it('should log a RecurringPayment record when there is one match', async () => {
-      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(jest.fn())
-      const onlyRecord = { entity: getMockRecurringPayment() }
-      dynamicsLib.executeQuery.mockReturnValueOnce([onlyRecord])
-
-      await linkRecurringPayments('existing-recurring-payment-id', 'agreement-id')
-
-      expect(consoleLogSpy).toHaveBeenCalledWith('newRecurringPaymentId: ', onlyRecord.id)
+    it('passes query created by findRecurringPaymentsByAgreementId to retrieveMultipleRequest', async () => {
+      const retrieveRequest = Symbol('retrieve request')
+      findRecurringPaymentsByAgreementId.mockReturnValueOnce({ toRetrieveRequest: () => retrieveRequest })
+      await findNewestExistingRecurringPaymentInCrm()
+      expect(dynamicsClient.retrieveMultipleRequest).toHaveBeenCalledWith(retrieveRequest)
     })
 
-    it('should log the RecurringPayment record with the latest endDate when there are multiple matches', async () => {
-      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(jest.fn())
-      const oldestRecord = { entity: getMockRecurringPayment({ id: Symbol('oldest'), endDate: new Date('2021-12-15T00:00:00Z') }) }
-      const newestRecord = { entity: getMockRecurringPayment({ id: Symbol('newest'), endDate: new Date('2023-12-15T00:00:00Z') }) }
-      const middlestRecord = { entity: getMockRecurringPayment({ id: Symbol('middlest'), endDate: new Date('2022-12-15T00:00:00Z') }) }
-      dynamicsLib.executeQuery.mockReturnValueOnce([oldestRecord, newestRecord, middlestRecord])
-
-      await linkRecurringPayments('existing-recurring-payment-id', 'agreement-id')
-
-      expect(consoleLogSpy).toHaveBeenCalledWith('newRecurringPaymentId: ', newestRecord.id)
+    it('returns a Recurring Payment (not a plain object)', async () => {
+      jest.spyOn(RecurringPayment, 'fromResponse')
+      dynamicsClient.retrieveMultipleRequest.mockReturnValueOnce(getMockResponse())
+      const rcp = await findNewestExistingRecurringPaymentInCrm()
+      expect(RecurringPayment.fromResponse.mock.results[0].value).toBe(rcp)
     })
 
-    it('should log no matches when there are no matches', async () => {
-      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(jest.fn())
-      dynamicsLib.executeQuery.mockReturnValueOnce([])
-
-      await linkRecurringPayments('existing-recurring-payment-id', 'agreement-id')
+    it.each([
+      [
+        'dataset of three with midpoint most recent',
+        [
+          { defra_recurringpaymentid: '1', defra_enddate: '2024-05-31T00:37:24.123' },
+          { defra_recurringpaymentid: '2', defra_enddate: '2025-05-31T00:37:24.456' },
+          { defra_recurringpaymentid: '3', defra_enddate: '2025-05-31T00:37:24.123' }
+        ],
+        '2'
+      ],
+      [
+        'dataset of five with penultimate most recent',
+        [
+          { defra_recurringpaymentid: '111-aaa', defra_enddate: '2024-05-31T00:37:24.123' },
+          { defra_recurringpaymentid: '222-ddd', defra_enddate: '2022-05-31T00:37:24.456' },
+          { defra_recurringpaymentid: '304-jkj', defra_enddate: '2021-05-31T00:37:24.123' },
+          { defra_recurringpaymentid: 'abc-123', defra_enddate: '2025-05-31T00:37:24.123' },
+          { defra_recurringpaymentid: '908-oid', defra_enddate: '1876-05-30T00:37:24.123' }
+        ],
+        'abc-123'
+      ],
+      [
+        'dataset of two with last most recent',
+        [
+          { defra_recurringpaymentid: 'abc-123', defra_enddate: '1876-05-30T00:37:24.123' },
+          { defra_recurringpaymentid: '908-oid', defra_enddate: '2025-05-31T00:37:24.123' }
+        ],
+        '908-oid'
+      ]
+    ])('returns most recent existing recurring payment from %s', async (_desc, mockResponseData, expectedId) => {
+      dynamicsClient.retrieveMultipleRequest.mockReturnValueOnce({ value: mockResponseData })
+      const rcp = await findNewestExistingRecurringPaymentInCrm()
+      expect(rcp.id).toBe(expectedId)
+    })
 
-      expect(consoleLogSpy).toHaveBeenCalledWith('No matches found')
+    it('returns boolean false if no recurring payments found', async () => {
+      dynamicsClient.retrieveMultipleRequest.mockReturnValueOnce({ value: [] })
+      const rcp = await findNewestExistingRecurringPaymentInCrm()
+      expect(rcp).toBeFalsy()
     })
   })
 })

package/src/services/recurring-payments.service.js

@@ -1,4 +1,10 @@
-import { executeQuery, findDueRecurringPayments, findRecurringPaymentsByAgreementId, RecurringPayment } from '@defra-fish/dynamics-lib'
+import {
+  executeQuery,
+  findDueRecurringPayments,
+  findRecurringPaymentsByAgreementId,
+  RecurringPayment,
+  dynamicsClient
+} from '@defra-fish/dynamics-lib'
 import { calculateEndDate, generatePermissionNumber } from './permissions.service.js'
 import { getObfuscatedDob } from './contacts.service.js'
 import { createHash } from 'node:crypto'
@@ -123,22 +129,12 @@ export const processRPResult = async (transactionId, paymentId, createdDate) =>
   return { permission }
 }
 
-export const linkRecurringPayments = async (existingRecurringPaymentId, agreementId) => {
-  console.log('existingRecurringPaymentId: ', existingRecurringPaymentId)
-  console.log('agreementId: ', agreementId)
-  const newRecurringPayment = await findNewestExistingRecurringPaymentInCrm(agreementId)
-  if (newRecurringPayment) {
-    console.log('newRecurringPaymentId: ', newRecurringPayment.id)
-  } else {
-    console.log('No matches found')
-  }
-}
-
-const findNewestExistingRecurringPaymentInCrm = async agreementId => {
-  const matchingRecords = await executeQuery(findRecurringPaymentsByAgreementId(agreementId))
-  if (matchingRecords?.length) {
-    return [...matchingRecords].sort((a, b) => a.entity.endDate - b.entity.endDate).pop()
-  } else {
-    return false
+export const findNewestExistingRecurringPaymentInCrm = async agreementId => {
+  const query = findRecurringPaymentsByAgreementId(agreementId)
+  const response = await dynamicsClient.retrieveMultipleRequest(query.toRetrieveRequest())
+  if (response.value.length) {
+    const [rcpResponseData] = response.value.sort((a, b) => Date.parse(b.defra_enddate) - Date.parse(a.defra_enddate))
+    return RecurringPayment.fromResponse(rcpResponseData)
   }
+  return false
 }

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

@@ -1,14 +1,11 @@
 import { processQueue, getTransactionJournalRefNumber } from '../process-transaction-queue.js'
 import {
   persist,
-  findById,
   ConcessionProof,
   Contact,
   FulfilmentRequest,
   Permission,
-  PoclFile,
   RecurringPayment,
-  RecurringPaymentInstruction,
   Transaction,
   TransactionJournal
 } from '@defra-fish/dynamics-lib'
@@ -25,7 +22,11 @@ import {
 import { TRANSACTION_STAGING_TABLE, TRANSACTION_STAGING_HISTORY_TABLE } from '../../../config.js'
 import { POCL_DATA_SOURCE, DDE_DATA_SOURCE } from '@defra-fish/business-rules-lib'
 import moment from 'moment'
-import { processRecurringPayment, generateRecurringPaymentRecord } from '../../recurring-payments.service.js'
+import {
+  processRecurringPayment,
+  generateRecurringPaymentRecord,
+  findNewestExistingRecurringPaymentInCrm
+} from '../../recurring-payments.service.js'
 import { AWS } from '@defra-fish/connectors-lib'
 const { docClient } = AWS.mock.results[0].value
 
@@ -50,8 +51,7 @@ jest.mock('../../reference-data.service.js', () => ({
 
 jest.mock('@defra-fish/dynamics-lib', () => ({
   ...jest.requireActual('@defra-fish/dynamics-lib'),
-  persist: jest.fn(),
-  findById: jest.fn()
+  persist: jest.fn()
 }))
 
 jest.mock('../../contacts.service.js', () => ({
@@ -169,7 +169,36 @@ describe('transaction service', () => {
             expect.any(Contact),
             expect.any(Permission),
             expect.any(RecurringPayment),
-            expect.any(RecurringPaymentInstruction),
+            expect.any(ConcessionProof)
+          ]
+        ],
+        [
+          'licences with a previous recurring payment linked to new recurring payment',
+          () => {
+            processRecurringPayment.mockResolvedValueOnce({ recurringPayment: new RecurringPayment() })
+            findNewestExistingRecurringPaymentInCrm.mockResolvedValueOnce(new RecurringPayment())
+            const mockRecord = mockFinalisedTransactionRecord()
+            mockRecord.payment.recurring = {
+              name: 'Test name',
+              nextDueDate: new Date('2020/01/11'),
+              endDate: new Date('2022/01/16'),
+              agreementId: '123446jjng',
+              publicId: 'sdf-123',
+              status: 1,
+              activePermission: mockRecord.permissions[0],
+              contact: Object.assign(mockContactPayload(), { firstName: 'Esther' })
+            }
+            mockRecord.permissions[0].permitId = MOCK_12MONTH_SENIOR_PERMIT.id
+            return mockRecord
+          },
+          [
+            expect.any(Transaction),
+            expect.any(TransactionJournal),
+            expect.any(TransactionJournal),
+            expect.any(Contact),
+            expect.any(Permission),
+            expect.any(RecurringPayment),
+            expect.any(RecurringPayment),
             expect.any(ConcessionProof)
           ]
         ]
@@ -338,15 +367,13 @@ describe('transaction service', () => {
       expect(persistMockFirstAgument[0][4].isLicenceForYou).toBeUndefined()
     })
 
-    it('handles requests which relate to an transaction file', async () => {
+    it('handles requests which relate to a transaction file', async () => {
       const transactionFilename = 'test-file.xml'
       const mockRecord = mockFinalisedTransactionRecord()
       mockRecord.transactionFile = transactionFilename
       docClient.get.mockResolvedValueOnce({ Item: mockRecord })
       const transactionToFileBindingSpy = jest.spyOn(Transaction.prototype, 'bindToAlternateKey')
       const permissionToFileBindingSpy = jest.spyOn(Permission.prototype, 'bindToAlternateKey')
-      const testPoclFileEntity = new PoclFile()
-      findById.mockResolvedValueOnce(testPoclFileEntity)
       await processQueue({ id: mockRecord.id })
       expect(transactionToFileBindingSpy).toHaveBeenCalledWith(Transaction.definition.relationships.poclFile, transactionFilename)
       expect(permissionToFileBindingSpy).toHaveBeenCalledWith(Permission.definition.relationships.poclFile, transactionFilename)
@@ -428,6 +455,22 @@ describe('transaction service', () => {
         await processQueue({ id: finalisedTransaction.id })
         expect(processRecurringPayment).toHaveBeenCalledWith(rprSymbol, expect.any(Contact))
       })
+
+      it('binds existing recurring payment to new recurring payment', async () => {
+        const mockExistingRecurringPayment = {
+          bindToEntity: jest.fn()
+        }
+        const mockNewRecurringPayment = new RecurringPayment()
+        const finalisedTransaction = mockFinalisedTransactionRecord()
+        findNewestExistingRecurringPaymentInCrm.mockReturnValueOnce(mockExistingRecurringPayment)
+        processRecurringPayment.mockReturnValueOnce({ recurringPayment: mockNewRecurringPayment })
+        docClient.get.mockResolvedValueOnce({ Item: finalisedTransaction })
+        await processQueue({ id: finalisedTransaction.id })
+        expect(mockExistingRecurringPayment.bindToEntity).toHaveBeenCalledWith(
+          RecurringPayment.definition.relationships.nextRecurringPayment,
+          mockNewRecurringPayment
+        )
+      })
     })
   })
 

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

@@ -8,11 +8,15 @@ import {
   Transaction,
   TransactionCurrency,
   TransactionJournal,
-  RecurringPaymentInstruction
+  RecurringPayment
 } from '@defra-fish/dynamics-lib'
 import { DDE_DATA_SOURCE, FULFILMENT_SWITCHOVER_DATE, POCL_TRANSACTION_SOURCES } from '@defra-fish/business-rules-lib'
 import { getReferenceDataForEntityAndId, getGlobalOptionSetValue, getReferenceDataForEntity } from '../reference-data.service.js'
-import { generateRecurringPaymentRecord, processRecurringPayment } from '../recurring-payments.service.js'
+import {
+  generateRecurringPaymentRecord,
+  processRecurringPayment,
+  findNewestExistingRecurringPaymentInCrm
+} from '../recurring-payments.service.js'
 import { resolveContactPayload } from '../contacts.service.js'
 import { retrieveStagedTransaction } from './retrieve-transaction.js'
 import { TRANSACTION_STAGING_TABLE, TRANSACTION_STAGING_HISTORY_TABLE } from '../../config.js'
@@ -77,11 +81,11 @@ export async function processQueue ({ id }) {
 
     if (recurringPayment && permit.isRecurringPaymentSupported) {
       entities.push(recurringPayment)
-      const paymentInstruction = new RecurringPaymentInstruction()
-      paymentInstruction.bindToEntity(RecurringPaymentInstruction.definition.relationships.licensee, contact)
-      paymentInstruction.bindToEntity(RecurringPaymentInstruction.definition.relationships.permit, permit)
-      paymentInstruction.bindToEntity(RecurringPaymentInstruction.definition.relationships.recurringPayment, recurringPayment)
-      entities.push(paymentInstruction)
+      const existingRP = await findNewestExistingRecurringPaymentInCrm(recurringPayment.agreementId)
+      if (existingRP) {
+        existingRP.bindToEntity(RecurringPayment.definition.relationships.nextRecurringPayment, recurringPayment)
+        entities.push(existingRP)
+      }
     }
 
     for (const concession of concessions || []) {