Make order of operations requirement (equipment then get cached events) even clearer

Author: Lan2u

src/index.ts

@@ -104,10 +104,16 @@ void (async () => {
       elapsedNs / (1000 * 1000)
     )
   )(
-    loadCachedSheetData(
-      deps.getCachedSheetData,
-      deps.logger,
-      deps.sharedReadModel
+    Promise.all(
+      deps.sharedReadModel.equipment
+        .getAll()
+        .map(
+          loadCachedSheetData(
+            deps.getCachedSheetData,
+            deps.logger,
+            deps.sharedReadModel.updateState
+          )
+        )
     )
   );
   await deps.sharedReadModel.asyncApplyExternalEventSources()();

src/load-cached-sheet-data.ts

@@ -2,16 +2,17 @@ import {Logger} from 'pino';
 import * as E from 'fp-ts/Either';
 import * as O from 'fp-ts/Option';
 import {Dependencies} from './dependencies';
-import {SharedReadModel} from './read-models/shared-state';
+import {Equipment} from './read-models/shared-state/return-types';
 
-export const loadCachedSheetData = async (
-  getCachedSheetData: Dependencies['getCachedSheetData'],
-  logger: Logger,
-  sharedReadModel: SharedReadModel
-) => {
-  // We only load cached training events for equipment we know about.
-  logger = logger.child({section: 'loadCachedSheetData'});
-  for (const equipment of sharedReadModel.equipment.getAll()) {
+export const loadCachedSheetData =
+  (
+    getCachedSheetData: Dependencies['getCachedSheetData'],
+    logger: Logger,
+    updateState: Dependencies['sharedReadModel']['updateState']
+  ) =>
+  async (equipment: Equipment) => {
+    // We only load cached training events for equipment we know about.
+    logger = logger.child({section: 'loadCachedSheetData'});
     const equipmentLogger = logger.child({
       equipment_name: equipment.name,
       equipment_id: equipment.id,
@@ -26,7 +27,7 @@ export const loadCachedSheetData = async (
       equipmentLogger.info(
         'Equipment has no training sheet id - not loading any cached data'
       );
-      continue;
+      return;
     }
     equipmentLogger.info('Loading cached sheet data for sheet');
     const cachedSheetData = await getCachedSheetData(
@@ -42,7 +43,7 @@ export const loadCachedSheetData = async (
     } else {
       if (O.isNone(cachedSheetData.right)) {
         equipmentLogger.info('No cached events found');
-        continue;
+        return;
       }
       const loadedData = cachedSheetData.right.value;
       const sheetDataLogger = equipmentLogger.child({
@@ -66,10 +67,9 @@ export const loadCachedSheetData = async (
               cachedEvent.equipmentId
             );
           } else {
-            sharedReadModel.updateState(cachedEvent);
+            updateState(cachedEvent);
           }
         }
       }
     }
-  }
-};
+  };

src/util.ts

@@ -66,7 +66,8 @@ export const fieldIsUUID =
     E.isRight(tt.UUID.decode(obj[key]));
 
 export const timeAsync =
-  (callback: (nanoseconds: number) => void) => async (fn: Promise<void>) => {
+  (callback: (nanoseconds: number) => void) =>
+  async (fn: PromiseLike<void | void[]>) => {
     const start = process.hrtime.bigint();
     const result = await fn;
     // Realistically we aren't going to be have elapsed periods big enough that this conversion back to number is problematic.