feat(gsul): exclude post-dated updates that have not yet taken effect

Author: tstephen-nhs

packages/gsul/src/dynamoDBclient.ts

@@ -40,7 +40,10 @@ export async function getItemsUpdatesForPrescription(
     itemId: String(singleUpdate.LineItemID),
     latestStatus: String(singleUpdate.Status),
     isTerminalState: String(singleUpdate.TerminalStatus) === "completed",
-    lastUpdateDateTime: String(singleUpdate.LastModified)
+    lastUpdateDateTime: String(singleUpdate.LastModified),
+    ...(singleUpdate.PostDatedLastModifiedSetAt && {
+      postDatedLastModifiedSetAt: String(singleUpdate.PostDatedLastModifiedSetAt)
+    })
   }))
 }
 

packages/gsul/src/getStatusUpdates.ts

@@ -27,7 +27,7 @@ const lambdaHandler = async (event: requestType): Promise<responseType> => {
   // this is an async map so it returns an array of promises
   const itemResults = event.prescriptions.map(async (prescription) => {
     const queryResult = await getItemsUpdatesForPrescription(prescription.prescriptionID, prescription.odsCode, logger)
-    return buildResult(prescription, queryResult)
+    return filterOutPostDatedUpdates(prescription, queryResult)
   })
 
   // wait for all the promises to complete
@@ -40,21 +40,60 @@ const lambdaHandler = async (event: requestType): Promise<responseType> => {
   return response
 }
 
-export const buildResult = (
+export const filterOutPostDatedUpdates = (
   inputPrescription: inputPrescriptionType,
-  items: Array<itemType>
+  items: Array<itemType>,
+  currentTime: number = Date.now() // injectable for testing
 ): outputPrescriptionType => {
-  // get unique item ids with the latest update based on lastUpdateDateTime
-  const uniqueItems: Array<itemType> = Object.values(
-    items.reduce(function (r, e) {
-      if (!r[e.itemId] || Date.parse(e.lastUpdateDateTime) > Date.parse(r[e.itemId].lastUpdateDateTime)) r[e.itemId] = e
-      return r
-    }, {})
-  )
+
+  // filter out items with future lastUpdateDateTime
+  const validTimeUpdates = items.filter(item => {
+    const updateTime = Date.parse(item.lastUpdateDateTime)
+    return updateTime <= currentTime
+  })
+
+  // group by itemId and separate post-dated from regular updates
+  const itemGroups: Record<string, {regular: itemType | null, postDated: itemType | null}> = {}
+
+  validTimeUpdates.forEach(item => {
+    if (!itemGroups[item.itemId]) {
+      itemGroups[item.itemId] = {regular: null, postDated: null}
+    }
+    const group = itemGroups[item.itemId]
+
+    if (item.postDatedLastModifiedSetAt) { // this is a post-dated update
+      if (!group.postDated) {
+        group.postDated = item
+      } else {
+        const existingTime = Date.parse(group.postDated.postDatedLastModifiedSetAt!)
+        const newTime = Date.parse(item.postDatedLastModifiedSetAt)
+        if (newTime > existingTime) {
+          group.postDated = item
+        }
+      }
+    } else { // this is a regular update
+      if (!group.regular) {
+        group.regular = item
+      } else {
+        const existingTime = Date.parse(group.regular.lastUpdateDateTime)
+        const newTime = Date.parse(item.lastUpdateDateTime)
+        if (newTime > existingTime) {
+          group.regular = item
+        }
+      }
+    }
+  })
+
+  // flatten both regular and post-dated updates into single array
+  const uniqueItems: Array<itemType> = []
+  Object.values(itemGroups).forEach(group => {
+    if (group.regular) uniqueItems.push(group.regular)
+    if (group.postDated) uniqueItems.push(group.postDated)
+  })
 
   const result: outputPrescriptionType = {
     prescriptionID: inputPrescription.prescriptionID,
-    onboarded: items.length > 0,
+    onboarded: items.length > 0, // consider onboarded even if all updates were post-dated
     items: uniqueItems
   }
   return result

packages/gsul/src/schema/response.ts

@@ -15,6 +15,9 @@ const itemSchema = {
     },
     lastUpdateDateTime: {
       type: "string"
+    },
+    postDatedLastModifiedSetAt: {
+      type: "string"
     }
   }
 } as const

packages/gsul/tests/testBuildResult.test.ts

@@ -1,4 +1,4 @@
-import {buildResult} from "../src/getStatusUpdates"
+import {filterOutPostDatedUpdates} from "../src/getStatusUpdates"
 import {inputPrescriptionType} from "../src/schema/request"
 import {outputPrescriptionType, itemType} from "../src/schema/response"
 
@@ -83,7 +83,7 @@ const scenarios: Array<scenariosType> = [
     }
   },
   {
-    scenarioDescription: "should return correct data for multiple items",
+    scenarioDescription: "should return latest item for multiple updates for each of multiple statuses",
     inputPrescriptions: {
       prescriptionID: "abc",
       odsCode: "123"
@@ -132,11 +132,82 @@ const scenarios: Array<scenariosType> = [
         }
       ]
     }
+  },
+  {
+    scenarioDescription: "should exclude item when post-dated update hasn't matured",
+    inputPrescriptions: {
+      prescriptionID: "abc",
+      odsCode: "123"
+    },
+    queryResults: [
+      {
+        itemId: "item_1",
+        latestStatus: "Ready to collect",
+        isTerminalState: false,
+        lastUpdateDateTime: "2030-01-01T00:00:00Z", // Future, no fallback
+        postDatedLastModifiedSetAt:"1972-01-01T00:00:00Z"
+      }
+    ],
+    expectedResult: {
+      prescriptionID: "abc",
+      onboarded: true,
+      items: []
+    }
+  },
+  {
+    scenarioDescription: "should use latest post-dated update when multiple have matured",
+    inputPrescriptions: {
+      prescriptionID: "abc",
+      odsCode: "123"
+    },
+    queryResults: [
+      {
+        itemId: "item_1",
+        latestStatus: "With pharmacy",
+        isTerminalState: false,
+        lastUpdateDateTime: "1970-01-01T00:00:00Z"
+      },
+      {
+        itemId: "item_1",
+        latestStatus: "Ready to collect",
+        isTerminalState: false,
+        lastUpdateDateTime: "1971-01-01T00:00:00Z",
+        postDatedLastModifiedSetAt: "1970-01-02T00:00:00Z"
+      },
+      {
+        itemId: "item_1",
+        latestStatus: "Ready to collect",
+        isTerminalState: false,
+        lastUpdateDateTime: "1972-01-01T00:00:00Z",
+        postDatedLastModifiedSetAt: "1971-01-02T00:00:00Z"
+      }
+    ],
+    expectedResult: {
+      prescriptionID: "abc",
+      onboarded: true,
+      items: [
+        {
+          itemId: "item_1",
+          latestStatus: "With pharmacy",
+          isTerminalState: false,
+          lastUpdateDateTime: "1970-01-01T00:00:00Z"
+        },
+        {
+          itemId: "item_1",
+          latestStatus: "Ready to collect",
+          isTerminalState: false,
+          lastUpdateDateTime: "1972-01-01T00:00:00Z",
+          postDatedLastModifiedSetAt: "1971-01-02T00:00:00Z"
+        }
+      ]
+    }
   }
 ]
 describe("Unit tests for buildResults", () => {
   it.each<scenariosType>(scenarios)("$scenarioDescription", ({inputPrescriptions, queryResults, expectedResult}) => {
-    const result = buildResult(inputPrescriptions, queryResults)
+    // Use a fixed time of 2000-01-01 for tests (946684800000 ms since epoch)
+    const fixedCurrentTime = new Date("2000-01-01T00:00:00Z").getTime()
+    const result = filterOutPostDatedUpdates(inputPrescriptions, queryResults, fixedCurrentTime)
     expect(result).toMatchObject(expectedResult)
   })
 })