@defra-fish/connectors-lib 1.63.0-rc.0 → 1.63.0-rc.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/connectors-lib",
-  "version": "1.63.0-rc.0",
+  "version": "1.63.0-rc.10",
   "description": "Shared connectors",
   "type": "module",
   "engines": {
@@ -46,5 +46,5 @@
     "node-fetch": "^2.7.0",
     "redlock": "^4.2.0"
   },
-  "gitHead": "127bd6db86a97eb1b229f3de30e27046119ffca6"
+  "gitHead": "c4301461b148cbf244c1bb5c834521243ec0a534"
 }

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

@@ -1,6 +1,6 @@
 import { createDocumentClient } from '../documentclient-decorator'
 import { DynamoDB } from '@aws-sdk/client-dynamodb'
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb'
+import { DynamoDBDocument, QueryCommand, ScanCommand } from '@aws-sdk/lib-dynamodb'
 
 jest.mock('@aws-sdk/client-dynamodb')
 jest.mock('@aws-sdk/lib-dynamodb')
@@ -9,6 +9,7 @@ describe('document client decorations', () => {
   beforeAll(() => {
     jest.spyOn(global, 'setTimeout').mockImplementation(cb => cb())
     DynamoDBDocument.from.mockReturnValue({
+      send: jest.fn().mockResolvedValue({ Items: [], lastEvaluatedKey: false }),
       query: jest.fn().mockResolvedValue({ Items: [], lastEvaluatedKey: false }),
       scan: jest.fn().mockResolvedValue({ Items: [], lastEvaluatedKey: false }),
       batchWrite: jest.fn().mockResolvedValue({ UnprocessedItems: {} })
@@ -46,23 +47,30 @@ describe('document client decorations', () => {
   })
 
   describe.each`
-    aggregateMethod      | baseMethod
-    ${'queryAllPromise'} | ${'query'}
-    ${'scanAllPromise'}  | ${'scan'}
-  `('$aggregateMethod', ({ aggregateMethod, baseMethod }) => {
+    aggregateMethod      | commandType
+    ${'queryAllPromise'} | ${QueryCommand}
+    ${'scanAllPromise'}  | ${ScanCommand}
+  `('$aggregateMethod', ({ aggregateMethod, commandType }) => {
     it('is added to document client', () => {
       const docClient = createDocumentClient()
       expect(docClient[aggregateMethod]).toBeDefined()
     })
 
-    it(`passes arguments provided for ${aggregateMethod} to ${baseMethod}`, async () => {
+    it(`passes arguments provided for ${aggregateMethod} to ${commandType.name}`, async () => {
       const params = { TableName: 'TEST', KeyConditionExpression: 'id = :id', ExpressionAttributeValues: { ':id': 1 } }
       const docClient = createDocumentClient()
       await docClient[aggregateMethod](params)
-      expect(docClient[baseMethod]).toHaveBeenCalledWith(params)
+      expect(commandType).toHaveBeenCalledWith(params)
     })
 
-    it(`calls ${baseMethod} repeatedly until LastEvaluatedKey evaluates to false, concatenating all returned items`, async () => {
+    it(`passes created command ${commandType.name} to docClient.send`, async () => {
+      const docClient = createDocumentClient()
+      await docClient[aggregateMethod]()
+      const [command] = commandType.mock.instances
+      expect(docClient.send).toHaveBeenCalledWith(command)
+    })
+
+    it('calls send repeatedly until LastEvaluatedKey evaluates to false, concatenating all returned items', async () => {
       const expectedItems = [
         { id: 1, data: Symbol('data1') },
         { id: 2, data: Symbol('data2') },
@@ -71,7 +79,7 @@ describe('document client decorations', () => {
         { id: 5, data: Symbol('data5') }
       ]
       const docClient = createDocumentClient()
-      docClient[baseMethod]
+      docClient.send
         .mockResolvedValueOnce({ Items: expectedItems.slice(0, 2), LastEvaluatedKey: true })
         .mockResolvedValueOnce({ Items: expectedItems.slice(2, 4), LastEvaluatedKey: true })
         .mockResolvedValueOnce({ Items: expectedItems.slice(4), LastEvaluatedKey: false })
@@ -79,13 +87,12 @@ describe('document client decorations', () => {
       expect(actualItems).toEqual(expectedItems)
     })
 
-    it(`whilst concatenating ${baseMethod} results, passes ExclusiveStartKey param`, async () => {
+    it(`whilst concatenating ${commandType.name} results, passes ExclusiveStartKey param`, async () => {
       const expectedKey = Symbol('🔑')
       const docClient = createDocumentClient()
-      docClient[baseMethod].mockResolvedValueOnce({ Items: [], LastEvaluatedKey: expectedKey }).mockResolvedValueOnce({ Items: [] })
+      docClient.send.mockResolvedValueOnce({ Items: [], LastEvaluatedKey: expectedKey }).mockResolvedValueOnce({ Items: [] })
       await docClient[aggregateMethod]()
-      expect(docClient[baseMethod]).toHaveBeenNthCalledWith(
-        2,
+      expect(commandType).toHaveBeenLastCalledWith(
         expect.objectContaining({
           ExclusiveStartKey: expectedKey
         })
@@ -95,7 +102,7 @@ describe('document client decorations', () => {
     it("omits ExclusiveStartKey if previous LastEvaluatedKey isn't available", async () => {
       const docClient = createDocumentClient()
       await docClient[aggregateMethod]()
-      expect(docClient[baseMethod]).toHaveBeenNthCalledWith(
+      expect(docClient.send).toHaveBeenNthCalledWith(
         1,
         expect.not.objectContaining({
           ExclusiveStartKey: expect.anything()

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

@@ -746,4 +746,44 @@ describe('sales-api-connector', () => {
       await expect(salesApi.cancelRecurringPayment('id')).rejects.toThrow('Internal Server Error')
     })
   })
+
+  describe('retrieveStagedTransaction', () => {
+    describe.each([['id'], ['abc-123']])("Retrieving staged transaction id '%s'", id => {
+      beforeEach(() => {
+        fetch.mockReturnValue({
+          ok: true,
+          status: 200,
+          statusText: 'OK',
+          text: async () => JSON.stringify({ id })
+        })
+      })
+
+      it('calls the endpoint with the correct parameters', async () => {
+        await salesApi.retrieveStagedTransaction(id)
+
+        expect(fetch).toHaveBeenCalledWith(`http://0.0.0.0:4000/retrieveStagedTransaction/${id}`, {
+          method: 'get',
+          headers: expect.any(Object),
+          timeout: 20000
+        })
+      })
+
+      it('returns the expected response data', async () => {
+        const processedResult = await salesApi.retrieveStagedTransaction(id)
+
+        expect(processedResult).toEqual({ id })
+      })
+    })
+
+    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.retrieveStagedTransaction('id')).rejects.toThrow('Internal Server Error')
+    })
+  })
 })

package/src/documentclient-decorator.js

@@ -1,6 +1,6 @@
 import db from 'debug'
 import { DynamoDB } from '@aws-sdk/client-dynamodb'
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb'
+import { DynamoDBDocument, QueryCommand, ScanCommand } from '@aws-sdk/lib-dynamodb'
 const debug = db('connectors:aws')
 
 export const createDocumentClient = options => {
@@ -13,23 +13,24 @@ export const createDocumentClient = options => {
   })
 
   // Support for large query/scan operations which return results in pages
-  const wrapPagedDocumentClientOperation = operationName => {
+  const wrapPagedDocumentClientOperation = CommandType => {
     return async params => {
       const items = []
       let lastEvaluatedKey = null
       do {
-        const response = await docClient[operationName]({
+        const command = new CommandType({
           ...params,
           ...(lastEvaluatedKey && { ExclusiveStartKey: lastEvaluatedKey })
         })
+        const response = await docClient.send(command)
         lastEvaluatedKey = response.LastEvaluatedKey
         response.Items && items.push(...response.Items)
       } while (lastEvaluatedKey)
       return items
     }
   }
-  docClient.queryAllPromise = wrapPagedDocumentClientOperation('query')
-  docClient.scanAllPromise = wrapPagedDocumentClientOperation('scan')
+  docClient.queryAllPromise = wrapPagedDocumentClientOperation(QueryCommand)
+  docClient.scanAllPromise = wrapPagedDocumentClientOperation(ScanCommand)
 
   /**
    * Handles batch writes which may return UnprocessedItems. If UnprocessedItems are returned then they will be retried with exponential backoff

package/src/sales-api-connector.js

@@ -319,3 +319,14 @@ export const processRPResult = async (transactionId, paymentId, createdDate) =>
 export const cancelRecurringPayment = async id => {
   return exec2xxOrThrow(call(new URL(`/cancelRecurringPayment/${id}`, urlBase), 'get'))
 }
+
+/**
+ * Retrieve a staged transaction
+ *
+ * @param id
+ * @returns {Promise<*>}
+ * @throws on a non-2xx response
+ */
+export const retrieveStagedTransaction = async id => {
+  return exec2xxOrThrow(call(new URL(`/retrieveStagedTransaction/${id}`, urlBase), 'get'))
+}