@defra-fish/connectors-lib 1.61.0-rc.8 → 1.61.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@defra-fish/connectors-lib",
-  "version": "1.61.0-rc.8",
+  "version": "1.61.0",
   "description": "Shared connectors",
   "type": "module",
   "engines": {
-    "node": ">=18.17"
+    "node": ">=20"
   },
   "keywords": [
     "rod",
@@ -35,12 +35,16 @@
   },
   "dependencies": {
     "@airbrake/node": "^2.1.7",
-    "aws-sdk": "^2.1074.0",
+    "@aws-sdk/client-dynamodb": "^3.0.0",
+    "@aws-sdk/client-s3": "^3.0.0",
+    "@aws-sdk/client-secrets-manager": "^3.0.0",
+    "@aws-sdk/client-sqs": "^3.0.0",
+    "@aws-sdk/lib-dynamodb": "^3.0.0",
     "debug": "^4.3.3",
     "http-status-codes": "^2.3.0",
     "ioredis": "^4.28.5",
-    "node-fetch": "^2.6.7",
+    "node-fetch": "^2.7.0",
     "redlock": "^4.2.0"
   },
-  "gitHead": "6ee197c0caa5d83c4b111f6a382eee271d1e4f61"
+  "gitHead": "8d1841265a40178f285288e5323a36e887483434"
 }

package/src/__tests__/__snapshots__/document-client-decorator.spec.js.snap

@@ -0,0 +1,36 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`document client decorations createUpdateExpression transforms object to an update expression, with provided attribute names and values 1`] = `
+Object {
+  "ExpressionAttributeNames": Object {
+    "#payload": "payload",
+    "#payment": "payment",
+    "#permissions": "permissions",
+    "#status": "status",
+  },
+  "ExpressionAttributeValues": Object {
+    ":payload": Object {
+      "id": "abc-123",
+      "name": "ABCDE-123JJ-ABK12",
+      "type": "ddd-111-ggg-888",
+    },
+    ":payment": Object {
+      "amount": 16.32,
+      "method": "barter",
+      "source": "credit",
+      "timestamp": "2025-04-09T11:53:17.854Z",
+    },
+    ":permissions": Array [
+      Object {
+        "id": "abc-123",
+        "name": "ABCDE-123JJ-ABK12",
+        "type": "ddd-111-ggg-888",
+      },
+    ],
+    ":status": Object {
+      "id": "finalised",
+    },
+  },
+  "UpdateExpression": "SET #payload = :payload,#permissions = :permissions,#status = :status,#payment = :payment",
+}
+`;

package/src/__tests__/aws.spec.js

@@ -1,58 +1,112 @@
 import Config from '../config.js'
-const TEST_ENDPOINT = 'http://localhost:8080'
-jest.dontMock('aws-sdk')
-describe('aws connectors', () => {
-  it('configures dynamodb with a custom endpoint if one is defined in configuration', async () => {
-    Config.aws.dynamodb.endpoint = TEST_ENDPOINT
-    const { ddb } = require('../aws.js').default()
-    expect(ddb.config.endpoint).toEqual(TEST_ENDPOINT)
+import AWS from '../aws.js'
+import { DynamoDB } from '@aws-sdk/client-dynamodb'
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb'
+import { createDocumentClient } from '../documentclient-decorator.js'
+
+jest.mock('../documentclient-decorator.js')
+
+describe('AWS Special cases', () => {
+  it('document client passes convertEmptyValues flag', () => {
+    let spiedOptions
+    createDocumentClient.mockImplementation(options => {
+      spiedOptions = options
+      const client = new DynamoDB(options)
+      return DynamoDBDocument.from(client)
+    })
+    AWS()
+    expect(spiedOptions).toEqual(
+      expect.objectContaining({
+        convertEmptyValues: true
+      })
+    )
   })
 
-  it('configures sqs with a custom endpoint if one is defined in configuration', async () => {
-    Config.aws.sqs.endpoint = TEST_ENDPOINT
-    const { sqs } = require('../aws.js').default()
-    expect(sqs.config.endpoint).toEqual(TEST_ENDPOINT)
+  it('exports ListObjectsV2Command from S3 SDK', () => {
+    const { ListObjectsV2Command } = AWS()
+    expect(ListObjectsV2Command).toBeDefined()
   })
 
-  it('uses the default dynamodb endpoint if it is not overridden in configuration', async () => {
-    process.env.AWS_REGION = 'eu-west-2'
-    delete Config.aws.dynamodb.endpoint
-    const { ddb } = require('../aws.js').default()
-    expect(ddb.config.endpoint).toEqual('dynamodb.eu-west-2.amazonaws.com')
+  describe('AWS connectors for S3Client', () => {
+    it('has region set to eu-west-2', async () => {
+      const { s3 } = AWS()
+      const region = await s3.config.region()
+      expect(region).toBe('eu-west-2')
+    })
+
+    it('sets forcePathStyle to true when endpoint is defined', () => {
+      Config.aws.s3.endpoint = 'http://localhost:8080'
+      const { s3 } = AWS()
+      expect(s3.config.forcePathStyle).toBe(true)
+      delete Config.aws.s3.endpoint
+    })
+
+    it('does not set forcePathStyle when no endpoint is defined', () => {
+      const { s3 } = AWS()
+      expect(s3.config.forcePathStyle).not.toBe(true)
+    })
   })
+})
 
-  it('uses the default sqs endpoint if it is not overridden in configuration', async () => {
-    process.env.AWS_REGION = 'eu-west-2'
-    delete Config.aws.sqs.endpoint
-    const { sqs } = require('../aws.js').default()
-    expect(sqs.config.endpoint).toEqual('sqs.eu-west-2.amazonaws.com')
+describe.each`
+  name                | clientName            | configName          | expectedAPIVersion
+  ${'ddb'}            | ${'DynamoDB'}         | ${''}               | ${'2012-08-10'}
+  ${'sqs'}            | ${'SQS'}              | ${''}               | ${'2012-11-05'}
+  ${'s3'}             | ${'S3Client'}         | ${'s3'}             | ${'2006-03-01'}
+  ${'secretsManager'} | ${'SecretsManager'}   | ${'secretsManager'} | ${'2017-10-17'}
+  ${'docClient'}      | ${'DynamoDBDocument'} | ${'dynamodb'}       | ${'2012-08-10'}
+`('AWS connectors for $clientName', ({ name, clientName, configName, expectedAPIVersion }) => {
+  beforeAll(() => {
+    createDocumentClient.mockImplementation(options => {
+      const client = new DynamoDB(options)
+      return DynamoDBDocument.from(client)
+    })
   })
 
-  it('configures s3 with a custom endpoint if one is defined in configuration', async () => {
-    Config.aws.s3.endpoint = TEST_ENDPOINT
-    const { s3 } = require('../aws.js').default()
-    expect(s3.config.endpoint).toEqual(TEST_ENDPOINT)
-    expect(s3.config.s3ForcePathStyle).toBeTruthy()
+  it(`exposes a ${clientName} client`, () => {
+    const { [name]: client } = AWS()
+    expect(client).toBeDefined()
   })
 
-  it('uses default s3 settings if a custom endpoint is not defined', async () => {
-    process.env.AWS_REGION = 'eu-west-2'
-    delete Config.aws.s3.endpoint
-    const { s3 } = require('../aws.js').default()
-    expect(s3.config.endpoint).toEqual('s3.eu-west-2.amazonaws.com')
-    expect(s3.config.s3ForcePathStyle).toBeFalsy()
+  it(`${name} client has type ${clientName}`, () => {
+    const { [name]: client } = AWS()
+    expect(client.constructor.name).toEqual(clientName)
   })
 
-  it('configures secretsmanager with a custom endpoint if one is defined in configuration', async () => {
-    Config.aws.secretsManager.endpoint = TEST_ENDPOINT
-    const { secretsManager } = require('../aws.js').default()
-    expect(secretsManager.config.endpoint).toEqual(TEST_ENDPOINT)
+  it(`configures ${name} with a custom endpoint if one is defined in configuration`, async () => {
+    Config.aws[configName || clientName.toLowerCase()].endpoint = 'http://localhost:8080'
+
+    const { [name]: client } = AWS()
+    const endpoint = await client.config.endpoint()
+
+    expect(endpoint).toEqual(
+      expect.objectContaining({
+        hostname: 'localhost',
+        port: 8080,
+        protocol: 'http:',
+        path: '/'
+      })
+    )
+  })
+
+  it(`leaves endpoint undefined for ${clientName}, reverting to the internal handling for the default endpoint if it is not set in config`, async () => {
+    Config.aws[configName || clientName.toLowerCase()].endpoint = 'http://localhost:8080'
+
+    const { [name]: client } = AWS()
+    const endpoint = await client.config.endpoint()
+
+    expect(endpoint).toEqual(
+      expect.objectContaining({
+        hostname: 'localhost',
+        port: 8080,
+        protocol: 'http:',
+        path: '/'
+      })
+    )
   })
 
-  it('uses default secretsmanager settings if a custom endpoint is not defined', async () => {
-    process.env.AWS_REGION = 'eu-west-2'
-    delete Config.aws.secretsManager.endpoint
-    const { secretsManager } = require('../aws.js').default()
-    expect(secretsManager.config.endpoint).toEqual('secretsmanager.eu-west-2.amazonaws.com')
+  it('uses expected apiVersion', () => {
+    const { [name]: client } = AWS()
+    expect(client.config.apiVersion).toEqual(expectedAPIVersion)
   })
 })

package/src/__tests__/document-client-decorator.spec.js

@@ -1,161 +1,218 @@
-import AWSSdk from 'aws-sdk'
-import AWS from '../aws.js'
-const { docClient } = AWS()
+import { createDocumentClient } from '../documentclient-decorator'
+import { DynamoDB } from '@aws-sdk/client-dynamodb'
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb'
+
+jest.mock('@aws-sdk/client-dynamodb')
+jest.mock('@aws-sdk/lib-dynamodb')
 
 describe('document client decorations', () => {
-  it('deals with pagination where DynamoDB returns a LastEvaluatedKey in a query response', async () => {
-    const testLastEvaluatedKey = { id: '16324258-85-92746491' }
-
-    AWSSdk.DynamoDB.DocumentClient.__setNextResponses(
-      'query',
-      {
-        Items: [],
-        LastEvaluatedKey: testLastEvaluatedKey
-      },
-      {
-        Items: []
-      }
-    )
-    await docClient.queryAllPromise({
-      TableName: 'TEST'
+  beforeAll(() => {
+    jest.spyOn(global, 'setTimeout').mockImplementation(cb => cb())
+    DynamoDBDocument.from.mockReturnValue({
+      query: jest.fn().mockResolvedValue({ Items: [], lastEvaluatedKey: false }),
+      scan: jest.fn().mockResolvedValue({ Items: [], lastEvaluatedKey: false }),
+      batchWrite: jest.fn().mockResolvedValue({ UnprocessedItems: {} })
     })
-    expect(AWSSdk.DynamoDB.DocumentClient.mockedMethods.query).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({
-        TableName: 'TEST'
-      })
-    )
-    expect(AWSSdk.DynamoDB.DocumentClient.mockedMethods.query).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        TableName: 'TEST',
-        ExclusiveStartKey: testLastEvaluatedKey
-      })
-    )
   })
+  afterEach(jest.clearAllMocks)
 
-  it('deals with pagination where DynamoDB returns a LastEvaluatedKey in a scan response', async () => {
-    const testLastEvaluatedKey = { id: '16324258-85-92746491' }
-
-    AWSSdk.DynamoDB.DocumentClient.__setNextResponses(
-      'scan',
-      {
-        Items: [],
-        LastEvaluatedKey: testLastEvaluatedKey
-      },
-      {
-        Items: []
-      }
-    )
-    await docClient.scanAllPromise({
-      TableName: 'TEST'
-    })
-    expect(AWSSdk.DynamoDB.DocumentClient.mockedMethods.scan).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({
-        TableName: 'TEST'
-      })
-    )
-    expect(AWSSdk.DynamoDB.DocumentClient.mockedMethods.scan).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        TableName: 'TEST',
-        ExclusiveStartKey: testLastEvaluatedKey
-      })
-    )
+  it('passes options to DynamoDB constructor', () => {
+    const options = {
+      option1: '1',
+      option2: 2,
+      option3: Symbol('option3')
+    }
+    createDocumentClient(options)
+    expect(DynamoDB).toHaveBeenCalledWith(options)
   })
 
-  it('deals with UnprocessedItems when making batchWrite requests to DynamoDB', async () => {
-    AWSSdk.DynamoDB.DocumentClient.__setNextResponses(
-      'batchWrite',
-      {
-        UnprocessedItems: {
-          NameOfTableToUpdate: [
-            { PutRequest: { Item: { key: '1', field: 'data1' } } },
-            { PutRequest: { Item: { key: '2', field: 'data2' } } }
-          ]
-        }
-      },
-      {
-        UnprocessedItems: null
-      }
-    )
-    await docClient.batchWriteAllPromise({
-      RequestItems: {
-        NameOfTableToUpdate: [
-          { PutRequest: { Item: { key: '1', field: 'data1' } } },
-          { PutRequest: { Item: { key: '2', field: 'data2' } } },
-          { PutRequest: { Item: { key: '3', field: 'data3' } } }
-        ]
-      }
-    })
-    expect(AWSSdk.DynamoDB.DocumentClient.mockedMethods.batchWrite).toHaveBeenCalledTimes(2)
-    expect(AWSSdk.DynamoDB.DocumentClient.mockedMethods.batchWrite).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({
-        RequestItems: {
-          NameOfTableToUpdate: [
-            { PutRequest: { Item: { key: '1', field: 'data1' } } },
-            { PutRequest: { Item: { key: '2', field: 'data2' } } },
-            { PutRequest: { Item: { key: '3', field: 'data3' } } }
-          ]
-        }
-      })
-    )
-    expect(AWSSdk.DynamoDB.DocumentClient.mockedMethods.batchWrite).toHaveBeenNthCalledWith(
-      2,
+  it('creates DynamoDBDocument using client', () => {
+    createDocumentClient()
+    const [mockClient] = DynamoDB.mock.instances
+    expect(DynamoDBDocument.from).toHaveBeenCalledWith(mockClient, expect.any(Object))
+  })
+
+  it('Sets options to strip empty and undefined values when marshalling to DynamoDB lists, sets and values', () => {
+    createDocumentClient()
+    expect(DynamoDBDocument.from).toHaveBeenCalledWith(
+      expect.any(Object),
       expect.objectContaining({
-        RequestItems: {
-          NameOfTableToUpdate: [
-            { PutRequest: { Item: { key: '1', field: 'data1' } } },
-            { PutRequest: { Item: { key: '2', field: 'data2' } } }
-          ]
+        marshallOptions: {
+          convertEmptyValues: true,
+          removeUndefinedValues: true
         }
       })
     )
   })
 
-  it('deals with UnprocessedItems when making batchWrite requests to DynamoDB up to the given retry limit', async () => {
-    const batchWriteResponses = Array(11).fill({
-      UnprocessedItems: {
-        NameOfTableToUpdate: [
-          { PutRequest: { Item: { key: '1', field: 'data1' } } },
-          { PutRequest: { Item: { key: '2', field: 'data2' } } }
-        ]
+  describe.each`
+    aggregateMethod      | baseMethod
+    ${'queryAllPromise'} | ${'query'}
+    ${'scanAllPromise'}  | ${'scan'}
+  `('$aggregateMethod', ({ aggregateMethod, baseMethod }) => {
+    it('is added to document client', () => {
+      const docClient = createDocumentClient()
+      expect(docClient[aggregateMethod]).toBeDefined()
+    })
+
+    it(`passes arguments provided for ${aggregateMethod} to ${baseMethod}`, async () => {
+      const params = { TableName: 'TEST', KeyConditionExpression: 'id = :id', ExpressionAttributeValues: { ':id': 1 } }
+      const docClient = createDocumentClient()
+      await docClient[aggregateMethod](params)
+      expect(docClient[baseMethod]).toHaveBeenCalledWith(params)
+    })
+
+    it(`calls ${baseMethod} repeatedly until LastEvaluatedKey evaluates to false, concatenating all returned items`, async () => {
+      const expectedItems = [
+        { id: 1, data: Symbol('data1') },
+        { id: 2, data: Symbol('data2') },
+        { id: 3, data: Symbol('data3') },
+        { id: 4, data: Symbol('data4') },
+        { id: 5, data: Symbol('data5') }
+      ]
+      const docClient = createDocumentClient()
+      docClient[baseMethod]
+        .mockResolvedValueOnce({ Items: expectedItems.slice(0, 2), LastEvaluatedKey: true })
+        .mockResolvedValueOnce({ Items: expectedItems.slice(2, 4), LastEvaluatedKey: true })
+        .mockResolvedValueOnce({ Items: expectedItems.slice(4), LastEvaluatedKey: false })
+      const actualItems = await docClient[aggregateMethod]()
+      expect(actualItems).toEqual(expectedItems)
+    })
+
+    it(`whilst concatenating ${baseMethod} results, passes ExclusiveStartKey param`, async () => {
+      const expectedKey = Symbol('🔑')
+      const docClient = createDocumentClient()
+      docClient[baseMethod].mockResolvedValueOnce({ Items: [], LastEvaluatedKey: expectedKey }).mockResolvedValueOnce({ Items: [] })
+      await docClient[aggregateMethod]()
+      expect(docClient[baseMethod]).toHaveBeenNthCalledWith(
+        2,
+        expect.objectContaining({
+          ExclusiveStartKey: expectedKey
+        })
+      )
+    })
+
+    it("omits ExclusiveStartKey if previous LastEvaluatedKey isn't available", async () => {
+      const docClient = createDocumentClient()
+      await docClient[aggregateMethod]()
+      expect(docClient[baseMethod]).toHaveBeenNthCalledWith(
+        1,
+        expect.not.objectContaining({
+          ExclusiveStartKey: expect.anything()
+        })
+      )
+    })
+  })
+
+  describe('batchWriteAllPromise', () => {
+    it('is added to document client', () => {
+      const docClient = createDocumentClient()
+      expect(docClient.batchWriteAllPromise).toBeDefined()
+    })
+
+    it('passes arguments provided for batchWriteAllPromise to batchWrite', async () => {
+      const params = { RequestItems: { TEST: [{ PutRequest: { Item: { id: 1, data: Symbol('data1') } } }] } }
+      const docClient = createDocumentClient()
+      await docClient.batchWriteAllPromise(params)
+      expect(docClient.batchWrite).toHaveBeenCalledWith(params)
+    })
+
+    it('calls batchWrite repeatedly until UnprocessedItems is empty', async () => {
+      const docClient = createDocumentClient()
+      docClient.batchWrite
+        .mockResolvedValueOnce({ UnprocessedItems: { key: true } })
+        .mockResolvedValueOnce({ UnprocessedItems: { key: true } })
+        .mockResolvedValueOnce({ UnprocessedItems: { key: true } })
+        .mockResolvedValueOnce({ UnprocessedItems: {} })
+      await docClient.batchWriteAllPromise({ RequestItems: { key: true } })
+      expect(docClient.batchWrite).toHaveBeenCalledTimes(4)
+    })
+
+    it.each([
+      [1, 500],
+      [2, 750],
+      [3, 1125],
+      [4, 1687.5],
+      [5, 2500],
+      [6, 2500],
+      [7, 2500],
+      [8, 2500],
+      [9, 2500],
+      [10, 2500]
+    ])('retries %i times with %i ms delay on final retry', async (retries, delay) => {
+      const docClient = createDocumentClient()
+      for (let i = 0; i < retries; i++) {
+        docClient.batchWrite.mockResolvedValueOnce({ UnprocessedItems: { key: true } })
       }
+      await docClient.batchWriteAllPromise({ RequestItems: { key: true } })
+      expect(setTimeout).toHaveBeenNthCalledWith(retries, expect.any(Function), delay)
     })
-    AWSSdk.DynamoDB.DocumentClient.__setNextResponses('batchWrite', ...batchWriteResponses)
-    const request = {
-      RequestItems: {
-        NameOfTableToUpdate: [
-          { PutRequest: { Item: { key: '1', field: 'data1' } } },
-          { PutRequest: { Item: { key: '2', field: 'data2' } } },
-          { PutRequest: { Item: { key: '3', field: 'data3' } } }
-        ]
+
+    it('throws an error on the eleventh retry', async () => {
+      const docClient = createDocumentClient()
+      for (let i = 0; i < 11; i++) {
+        docClient.batchWrite.mockResolvedValueOnce({ UnprocessedItems: { key: true } })
       }
-    }
-    // Don't delay on setTimeouts!
-    jest.spyOn(global, 'setTimeout').mockImplementation(cb => cb())
-    await expect(docClient.batchWriteAllPromise(request)).rejects.toThrow(
-      'Failed to write items to DynamoDB using batch write.  UnprocessedItems were returned and maxRetries has been reached.'
-    )
+      await expect(() => docClient.batchWriteAllPromise({ RequestItems: { key: true } })).rejects.toThrow()
+    })
+
+    it('adds unprocessed items to batchWrite request', async () => {
+      const token = Symbol('token')
+      const firstCallSymbol = Symbol('first call')
+      const secondCallSymbol = Symbol('second call')
+      const docClient = createDocumentClient()
+      docClient.batchWrite.mockResolvedValueOnce({ UnprocessedItems: { secondCallSymbol } })
+      await docClient.batchWriteAllPromise({ token, RequestItems: { firstCallSymbol } })
+      expect(docClient.batchWrite).toHaveBeenNthCalledWith(
+        2,
+        expect.objectContaining({
+          token,
+          RequestItems: { secondCallSymbol }
+        })
+      )
+    })
   })
 
-  it('provides a convenience method to simplify building an update expression for DynamoDB', async () => {
-    const test = {
-      name: 'name-value',
-      number: 123
-    }
-    expect(docClient.createUpdateExpression(test)).toStrictEqual({
-      UpdateExpression: 'SET #name = :name,#number = :number',
-      ExpressionAttributeNames: {
-        '#name': 'name',
-        '#number': 'number'
-      },
-      ExpressionAttributeValues: {
-        ':name': 'name-value',
-        ':number': 123
+  describe('createUpdateExpression', () => {
+    it('is added to document client', () => {
+      const docClient = createDocumentClient()
+      expect(docClient.createUpdateExpression).toBeDefined()
+    })
+
+    it('returns an object with UpdateExpression, ExpressionAttributeNames and ExpressionAttributeValues', () => {
+      const docClient = createDocumentClient()
+      const actual = docClient.createUpdateExpression({ id: 1, data: Symbol('data1') })
+      expect(actual).toEqual(
+        expect.objectContaining({
+          UpdateExpression: expect.any(String),
+          ExpressionAttributeNames: expect.any(Object),
+          ExpressionAttributeValues: expect.any(Object)
+        })
+      )
+    })
+
+    it('transforms object to an update expression, with provided attribute names and values', () => {
+      const permission = {
+        id: 'abc-123',
+        name: 'ABCDE-123JJ-ABK12',
+        type: 'ddd-111-ggg-888'
       }
+      const transaction = {
+        payload: permission,
+        permissions: [permission],
+        status: { id: 'finalised' },
+        payment: {
+          amount: 16.32,
+          method: 'barter',
+          source: 'credit',
+          timestamp: '2025-04-09T11:53:17.854Z'
+        }
+      }
+      const docClient = createDocumentClient()
+
+      const actual = docClient.createUpdateExpression(transaction)
+
+      expect(actual).toMatchSnapshot()
     })
   })
 })

package/src/__tests__/sales-api-connector.spec.js

@@ -706,52 +706,4 @@ describe('sales-api-connector', () => {
       })
     })
   })
-
-  describe('linkRecurringPayments', () => {
-    describe.each([
-      ['existing-recurring-payment-id', 'agreement-id'],
-      ['abc-123', 'def-456']
-    ])("Processing payment for transaction id '%s'", (existingRecurringPaymentId, agreementId) => {
-      beforeEach(() => {
-        fetch.mockReturnValue({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          text: async () => JSON.stringify({ existingRecurringPaymentId, agreementId })
-        })
-      })
-
-      it('calls the endpoint with the correct parameters', async () => {
-        await salesApi.linkRecurringPayments(existingRecurringPaymentId, agreementId)
-
-        expect(fetch).toHaveBeenCalledWith(`http://0.0.0.0:4000/linkRecurringPayments/${existingRecurringPaymentId}/${agreementId}`, {
-          method: 'get',
-          headers: expect.any(Object),
-          timeout: 20000
-        })
-      })
-
-      it('returns the expected response data', async () => {
-        const processedResult = await salesApi.linkRecurringPayments(existingRecurringPaymentId, agreementId)
-
-        expect(processedResult).toEqual({ existingRecurringPaymentId, agreementId })
-      })
-    })
-
-    it('throws an error on non-2xx response', async () => {
-      fetch.mockReturnValue({
-        ok: false,
-        status: 500,
-        statusText: 'Internal Server Error',
-        text: async () => 'Server Error'
-      })
-
-      await expect(salesApi.linkRecurringPayments('existing-recurring-payment-id', 'agreement-id')).rejects.toThrow('Internal Server Error')
-      expect(fetch).toHaveBeenCalledWith('http://0.0.0.0:4000/linkRecurringPayments/existing-recurring-payment-id/agreement-id', {
-        method: 'get',
-        headers: expect.any(Object),
-        timeout: 20000
-      })
-    })
-  })
 })

package/src/aws.js

@@ -1,7 +1,9 @@
 import Config from './config.js'
 import { createDocumentClient } from './documentclient-decorator.js'
-import AWS from 'aws-sdk'
-const { DynamoDB, SQS, S3, SecretsManager } = AWS
+import { DynamoDB } from '@aws-sdk/client-dynamodb'
+import { SQS } from '@aws-sdk/client-sqs'
+import { S3Client, ListObjectsV2Command } from '@aws-sdk/client-s3'
+import { SecretsManager } from '@aws-sdk/client-secrets-manager'
 
 export default function () {
   return {
@@ -24,11 +26,12 @@ export default function () {
         endpoint: Config.aws.sqs.endpoint
       })
     }),
-    s3: new S3({
+    s3: new S3Client({
+      region: 'eu-west-2',
       apiVersion: '2006-03-01',
       ...(Config.aws.s3.endpoint && {
         endpoint: Config.aws.s3.endpoint,
-        s3ForcePathStyle: true
+        forcePathStyle: true
       })
     }),
     secretsManager: new SecretsManager({
@@ -36,6 +39,7 @@ export default function () {
       ...(Config.aws.secretsManager.endpoint && {
         endpoint: Config.aws.secretsManager.endpoint
       })
-    })
+    }),
+    ListObjectsV2Command
   }
 }

package/src/documentclient-decorator.js

@@ -1,10 +1,16 @@
 import db from 'debug'
-import AWS from 'aws-sdk'
-const { DynamoDB } = AWS
+import { DynamoDB } from '@aws-sdk/client-dynamodb'
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb'
 const debug = db('connectors:aws')
 
 export const createDocumentClient = options => {
-  const docClient = new DynamoDB.DocumentClient(options)
+  const client = new DynamoDB(options)
+  const docClient = DynamoDBDocument.from(client, {
+    marshallOptions: {
+      convertEmptyValues: true,
+      removeUndefinedValues: true
+    }
+  })
 
   // Support for large query/scan operations which return results in pages
   const wrapPagedDocumentClientOperation = operationName => {
@@ -15,7 +21,7 @@ export const createDocumentClient = options => {
         const response = await docClient[operationName]({
           ...params,
           ...(lastEvaluatedKey && { ExclusiveStartKey: lastEvaluatedKey })
-        }).promise()
+        })
         lastEvaluatedKey = response.LastEvaluatedKey
         response.Items && items.push(...response.Items)
       } while (lastEvaluatedKey)
@@ -26,9 +32,9 @@ export const createDocumentClient = options => {
   docClient.scanAllPromise = wrapPagedDocumentClientOperation('scan')
 
   /**
-   * Handles batch writes which may return UnprocessedItems.  If UnprocessedItems are returned then they will be retried with exponential backoff
+   * Handles batch writes which may return UnprocessedItems. If UnprocessedItems are returned then they will be retried with exponential backoff
    *
-   * @param {DocumentClient.BatchWriteItemInput} params as per DynamoDB.DocumentClient.batchWrite
+   * @param {DocumentClient.BatchWriteCommandInput} params as per DynamoDB.DocumentClient.batchWrite
    * @returns {Promise<void>}
    */
   docClient.batchWriteAllPromise = async params => {
@@ -37,13 +43,13 @@ export const createDocumentClient = options => {
     let unprocessedItemsDelay = 500
     let maxRetries = 10
     while (hasUnprocessedItems) {
-      const result = await docClient.batchWrite(request).promise()
+      const result = await docClient.batchWrite(request)
       hasUnprocessedItems = !!Object.keys(result.UnprocessedItems ?? {}).length
       if (hasUnprocessedItems) {
         request = { ...params, RequestItems: result.UnprocessedItems }
         if (maxRetries-- === 0) {
           throw new Error(
-            'Failed to write items to DynamoDB using batch write.  UnprocessedItems were returned and maxRetries has been reached.'
+            'Failed to write items to DynamoDB using batch write. UnprocessedItems were returned and maxRetries has been reached.'
           )
         }
         await new Promise(resolve => setTimeout(resolve, unprocessedItemsDelay))

package/src/sales-api-connector.js

@@ -308,15 +308,3 @@ export const preparePermissionDataForRenewal = async referenceNumber =>
 export const processRPResult = async (transactionId, paymentId, createdDate) => {
   return exec2xxOrThrow(call(new URL(`/processRPResult/${transactionId}/${paymentId}/${createdDate}`, urlBase), 'get'))
 }
-
-/**
- * Link an old RecurringPayment to its replacement
- *
- * @param existingRecurringPaymentId
- * @param agreementId
- * @returns {Promise<*>}
- * @throws on a non-2xx response
- */
-export const linkRecurringPayments = async (existingRecurringPaymentId, agreementId) => {
-  return exec2xxOrThrow(call(new URL(`/linkRecurringPayments/${existingRecurringPaymentId}/${agreementId}`, urlBase), 'get'))
-}

package/src/__mocks__/aws-mock-helper.js

@@ -1,73 +0,0 @@
-import cloneDeep from 'clone-deep'
-export const configureAwsSdkMock = (AwsSdk = jest.genMockFromModule('aws-sdk')) => {
-  const configuredMocks = []
-  AwsSdk.__resetAll = () => configuredMocks.forEach(c => c.__init())
-
-  const configureMock = (awsClass, methodNames, defaultResponse) => {
-    configuredMocks.push(awsClass)
-    awsClass.mockedMethods = createHandlers(awsClass, methodNames, defaultResponse)
-
-    awsClass.mockImplementation(() => ({ ...awsClass.mockedMethods }))
-    awsClass.expectedResponses = {}
-    awsClass.nextResponses = {}
-    awsClass.expectedErrors = {}
-    awsClass.__init = (
-      { expectedResponses = {}, nextResponses = [], expectedErrors = {} } = {
-        expectedResponses: {},
-        nextResponses: {},
-        expectedErrors: {}
-      }
-    ) => {
-      awsClass.expectedResponses = expectedResponses
-      awsClass.nextResponses = nextResponses
-      awsClass.expectedErrors = expectedErrors
-    }
-    awsClass.__setResponse = (methodName, response) => {
-      awsClass.expectedResponses[methodName] = cloneDeep(response)
-    }
-    awsClass.__setNextResponses = (methodName, ...responses) => {
-      awsClass.nextResponses[methodName] = cloneDeep(responses)
-    }
-    awsClass.__throwWithErrorOn = (methodName, error = new Error('Test error')) => {
-      awsClass.expectedErrors[methodName] = error
-    }
-  }
-
-  const createHandlers = (awsClass, names, defaultResponse) => {
-    return names.reduce((acc, name) => {
-      acc[name] = jest.fn(() => ({
-        promise: jest.fn(async () => {
-          if (awsClass.expectedErrors[name]) {
-            throw awsClass.expectedErrors[name]
-          }
-          if (awsClass.nextResponses[name] && awsClass.nextResponses[name].length) {
-            return awsClass.nextResponses[name].shift()
-          }
-          return awsClass.expectedResponses[name] || defaultResponse
-        })
-      }))
-      return acc
-    }, {})
-  }
-
-  configureMock(AwsSdk.SQS, [
-    'listQueues',
-    'createQueue',
-    'deleteQueue',
-    'purgeQueue',
-    'sendMessage',
-    'receiveMessage',
-    'deleteMessage',
-    'deleteMessageBatch'
-  ])
-  configureMock(AwsSdk.DynamoDB, ['listTables', 'describeTable', 'getItem', 'putItem', 'query', 'scan'], {})
-  configureMock(
-    AwsSdk.DynamoDB.DocumentClient,
-    ['get', 'put', 'update', 'query', 'scan', 'delete', 'createSet', 'batchGet', 'batchWrite'],
-    {}
-  )
-  configureMock(AwsSdk.S3, ['listObjectsV2', 'getObject', 'putObject', 'headObject', 'deleteObject', 'upload', 'listBuckets', 'headBucket'])
-  configureMock(AwsSdk.SecretsManager, ['getSecretValue'])
-
-  return AwsSdk
-}

package/src/__mocks__/aws-sdk.js

@@ -1,3 +0,0 @@
-import { configureAwsSdkMock } from './aws-mock-helper.js'
-const AwsSdk = configureAwsSdkMock()
-export default AwsSdk