Load cached trouble sheet data

Author: Lan2u

src/index.ts

@@ -20,7 +20,10 @@ import * as libsqlClient from '@libsql/client';
 import cookieSession from 'cookie-session';
 import {initRoutes} from './routes';
 import {ensureCachedSheetDataTableExists} from './init-dependencies/google/ensure-cached-sheet-data-table-exists';
-import {loadCachedSheetData} from './load-cached-sheet-data';
+import {
+  loadCachedSheetData,
+  loadCachedTroubleTicketData,
+} from './load-cached-sheet-data';
 import {timeAsync} from './util';
 
 // Dependencies and Config
@@ -131,6 +134,31 @@ void (async () => {
     );
   }
 
+  await timeAsync(elapsedNs =>
+    deps.logger.info(
+      'Loaded cached trouble ticket events in %sms',
+      elapsedNs / (1000 * 1000)
+    )
+  )(
+    Promise.all([
+      pipe(
+        loadCachedTroubleTicketData(
+          deps.getCachedTroubleTicketData,
+          deps.sharedReadModel.updateState
+        ),
+        TE.match(
+          failure => {
+            deps.logger.warn(
+              'Failed to load cached trouble ticket data - continuing anyway: %s',
+              failure
+            );
+          },
+          _ => {}
+        )
+      )(),
+    ])
+  );
+
   server.listen(conf.PORT, () => {
     deps.logger.info({port: conf.PORT}, 'Server listening');
     if (conf.PUBLIC_URL.includes('localhost')) {

src/load-cached-sheet-data.ts

@@ -1,8 +1,15 @@
 import {Logger} from 'pino';
 import * as E from 'fp-ts/Either';
 import * as O from 'fp-ts/Option';
+import * as TE from 'fp-ts/TaskEither';
+import * as RA from 'fp-ts/ReadonlyArray';
 import {Dependencies} from './dependencies';
 import {Equipment} from './read-models/shared-state/return-types';
+import {pipe} from 'fp-ts/lib/function';
+import {TROUBLE_TICKET_RESPONSES_SHEET} from './read-models/shared-state/async-apply-external-event-sources';
+import {failureWithStatus} from './types/failure-with-status';
+import {StatusCodes} from 'http-status-codes';
+import {formatValidationErrors} from 'io-ts-reporters';
 
 export const loadCachedSheetData =
   (
@@ -73,3 +80,42 @@ export const loadCachedSheetData =
       }
     }
   };
+
+export const loadCachedTroubleTicketData = (
+  getCachedTroubleTicketData: Dependencies['getCachedTroubleTicketData'],
+  updateState: Dependencies['sharedReadModel']['updateState']
+) =>
+  pipe(
+    getCachedTroubleTicketData(TROUBLE_TICKET_RESPONSES_SHEET),
+    TE.flatMap(cacheData =>
+      pipe(
+        cacheData,
+        O.match(
+          () =>
+            TE.left(
+              failureWithStatus(
+                'No cached trouble data found',
+                StatusCodes.NOT_FOUND
+              )
+            ),
+          dataValidation =>
+            pipe(
+              dataValidation.cached_data,
+              E.match(
+                errs =>
+                  TE.left(
+                    failureWithStatus(
+                      `Cached trouble data is malformed: ${formatValidationErrors(errs).join(',')}`,
+                      StatusCodes.BAD_REQUEST
+                    )
+                  ),
+                data => TE.right(data)
+              )
+            )
+        )
+      )
+    ),
+    TE.map(loadedData => {
+      pipe(loadedData, RA.map(updateState));
+    })
+  );

src/read-models/shared-state/async-apply-external-event-sources.ts

@@ -35,7 +35,7 @@ import {extractTimestamp} from '../../google/util';
 const ROW_BATCH_SIZE = 200;
 const EXPECTED_TROUBLE_TICKET_RESPONSE_SHEET_NAME = 'Form Responses 1';
 const TROUBLE_TICKET_SYNC_INTERVAL = Duration.fromMillis(1000 * 60 * 20);
-const TROUBLE_TICKET_RESPONSES_SHEET =
+export const TROUBLE_TICKET_RESPONSES_SHEET =
   '1ZSQoCOyw4ss9JuriySQX04gISfFnb4MadNpPFkEYW84'; // FIXME - Make this configurable.
 
 const pullNewEquipmentQuizResultsForSheet = async (