fix: Speed up calculation of upcoming workouts

The upcoming workout logic was pretty inefficient, in that it would recalculate every 'latest' exercise by enumerating ever session ever. This meant that it could take in some cases half a second to calculate and show them which is wild. The new approach maintains an index in memory of the latest exercises as sessions are added to the state.

The downside of this approach is that deletes need to do this expensive calculation, but that is much less frequent than fetching upcoming workouts so this tradeoff is worth it.

I've seen times go from 300-700ms to < 80ms. Which is still pretty long in the grand scheme of things but a vast improvement.

Author: LiamMorrow

app/services/progress-repository.ts

@@ -1,9 +1,8 @@
-import { RecordedExercise, SessionPOJO } from '@/models/session-models';
+import { SessionPOJO } from '@/models/session-models';
 import { TemporalComparer } from '@/models/comparers';
 import { Session } from '@/models/session-models';
 import Enumerable from 'linq';
 import { RootState } from '@/store';
-import { KeyedExerciseBlueprint } from '@/models/blueprint-models';
 import { ZoneId } from '@js-joda/core';
 
 export class ProgressRepository {
@@ -32,19 +31,4 @@ export class ProgressRepository {
         TemporalComparer,
       );
   }
-
-  getLatestRecordedExercises(): Enumerable.IDictionary<
-    string,
-    RecordedExercise
-  > {
-    return this.getOrderedSessions()
-      .selectMany((x) => x.recordedExercises)
-      .groupBy((x) =>
-        KeyedExerciseBlueprint.fromExerciseBlueprint(x.blueprint).toString(),
-      )
-      .toDictionary(
-        (x) => x.key(),
-        (x) => x.first(),
-      );
-  }
 }

app/services/session-service.ts

@@ -17,7 +17,6 @@ import { ProgressRepository } from '@/services/progress-repository';
 import type { RootState } from '@/store';
 import { uuid } from '@/utils/uuid';
 import { LocalDate } from '@js-joda/core';
-import Enumerable from 'linq';
 import { match } from 'ts-pattern';
 
 export class SessionService {
@@ -26,9 +25,9 @@ export class SessionService {
     private getState: () => RootState,
   ) {}
 
-  // TODO this is super inefficient, it should probably be done ahead of time or with a dirty mark.
   async *getUpcomingSessions(
     sessionBlueprints: SessionBlueprint[],
+    latestExercises: Record<string, RecordedExercise | undefined>, // KeyedExerciseBlueprint -> Exercise
   ): AsyncIterableIterator<Session> {
     const currentState = this.getState();
     const currentSession = Session.fromPOJO(
@@ -40,9 +39,6 @@ export class SessionService {
     }
     await yieldToEventLoop();
 
-    const latestRecordedExercises =
-      this.progressRepository.getLatestRecordedExercises();
-    await yieldToEventLoop();
     let latestSession =
       currentSession ??
       this.progressRepository
@@ -53,7 +49,7 @@ export class SessionService {
     if (!latestSession) {
       latestSession = this.createNewSession(
         sessionBlueprints[0],
-        latestRecordedExercises,
+        latestExercises,
       );
       yield latestSession;
     }
@@ -62,24 +58,25 @@ export class SessionService {
       latestSession = this.getNextSession(
         latestSession,
         sessionBlueprints,
-        latestRecordedExercises,
+        latestExercises,
       );
       yield latestSession;
     }
   }
 
-  public hydrateSessionFromBlueprint(blueprint: SessionBlueprint): Session {
-    const latestRecordedExercises =
-      this.progressRepository.getLatestRecordedExercises();
-    return this.createNewSession(blueprint, latestRecordedExercises);
+  public hydrateSessionFromBlueprint(
+    blueprint: SessionBlueprint,
+    latestExercises: Record<string, RecordedExercise | undefined>, // KeyedExerciseBlueprint -> Exercise
+  ): Session {
+    return this.createNewSession(blueprint, latestExercises);
   }
 
   private getNextSession(
     previousSession: Session,
     sessionBlueprints: SessionBlueprint[],
-    latestRecordedExercises: Enumerable.IDictionary<
+    latestRecordedExercises: Record<
       string, //KeyedExerciseBlueprint,
-      RecordedExercise
+      RecordedExercise | undefined
     >,
   ): Session {
     const lastBlueprint = previousSession.blueprint;
@@ -96,17 +93,18 @@ export class SessionService {
 
   private createNewSession(
     sessionBlueprint: SessionBlueprint,
-    latestRecordedExercises: Enumerable.IDictionary<
+    latestRecordedExercises: Record<
       string, //KeyedExerciseBlueprint,
-      RecordedExercise
+      RecordedExercise | undefined
     >,
   ): Session {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const $this = this;
     function getNextExercise(e: ExerciseBlueprint): RecordedExercise {
-      const lastExercise = latestRecordedExercises.get(
-        KeyedExerciseBlueprint.fromExerciseBlueprint(e).toString(),
-      );
+      const lastExercise =
+        latestRecordedExercises[
+          KeyedExerciseBlueprint.fromExerciseBlueprint(e).toString()
+        ];
       if (e instanceof CardioExerciseBlueprint) {
         const cardioLastExercise =
           lastExercise instanceof RecordedCardioExercise

app/store/current-session/effects.ts

@@ -20,7 +20,10 @@ import {
 } from '@/store/current-session';
 import { addEffect } from '@/store/store';
 import { fetchUpcomingSessions, selectActiveProgram } from '@/store/program';
-import { addStoredSession } from '@/store/stored-sessions';
+import {
+  addStoredSession,
+  selectLatestExercises,
+} from '@/store/stored-sessions';
 import { selectPreferredWeightUnit } from '@/store/settings';
 import { diffSessionBlueprints } from '@/models/blueprint-diff';
 import { addUnpublishedSessionId } from '@/store/feed';
@@ -271,9 +274,13 @@ export function applyCurrentSessionEffects() {
 
   addEffect(
     setCurrentSessionFromBlueprint,
-    async (action, { dispatch, extra: { sessionService } }) => {
+    async (
+      action,
+      { stateAfterReduce, dispatch, extra: { sessionService } },
+    ) => {
       const session = sessionService.hydrateSessionFromBlueprint(
         action.payload.blueprint,
+        selectLatestExercises(stateAfterReduce),
       );
       dispatch(setCurrentSession({ session, target: action.payload.target }));
     },

app/store/program/effects.ts

@@ -19,6 +19,7 @@ import { LocalDate } from '@js-joda/core';
 import { AsyncStream } from 'data-async-iterators';
 import { KeyValueStore } from '@/services/key-value-store';
 import { Logger } from '@/services/logger';
+import { selectLatestExercises } from '../stored-sessions';
 
 const storageKey = 'SavedPrograms';
 const builtInProgramsStorageKey = 'hasSavedDefaultPlans2';
@@ -176,7 +177,10 @@ export function applyProgramEffects() {
       await yieldToEventLoop();
 
       const sessions = await AsyncStream.from(
-        sessionService.getUpcomingSessions(sessionBlueprints),
+        sessionService.getUpcomingSessions(
+          sessionBlueprints,
+          selectLatestExercises(state),
+        ),
       )
         .takeWhile(() => !signal.aborted)
         .take(numberOfUpcomingSessions)

app/store/stored-sessions/index.ts

@@ -1,19 +1,25 @@
 import {
+  fromRecordedExercisePOJO,
   RecordedExercise,
+  RecordedExercisePOJO,
   Session,
   SessionPOJO,
 } from '@/models/session-models';
 import {
   NormalizedName,
   NormalizedNameKey,
   ExerciseBlueprint,
+  KeyedExerciseBlueprint,
+  fromExerciseBlueprintPOJO,
+  ExerciseBlueprintPOJO,
 } from '@/models/blueprint-models';
-import { LocalDate, YearMonth, ZoneId } from '@js-joda/core';
+import { LocalDate, OffsetDateTime, YearMonth, ZoneId } from '@js-joda/core';
 import {
   createAction,
   createSelector,
   createSlice,
   PayloadAction,
+  WritableDraft,
 } from '@reduxjs/toolkit';
 import Enumerable from 'linq';
 import { WeightUnit } from '@/models/weight';
@@ -38,6 +44,7 @@ export interface WeightMigrateableExercise {
 interface StoredSessionState {
   isHydrated: boolean;
   sessions: Record<string, SessionPOJO>;
+  latestExercises: Record<string, RecordedExercisePOJO | undefined>; // KeyedExerciseBlueprint -> RecordedExercise
   savedExercises: Record<string, ExerciseDescriptor>;
   filteredExerciseIds: string[];
   exercisesRequiringWeightMigration: WeightMigrateableExercise[];
@@ -46,6 +53,7 @@ interface StoredSessionState {
 const initialState: StoredSessionState = {
   isHydrated: false,
   sessions: {},
+  latestExercises: {},
   savedExercises: {},
   filteredExerciseIds: [],
   exercisesRequiringWeightMigration: [],
@@ -66,15 +74,43 @@ const storedSessionsSlice = createSlice({
     },
 
     upsertStoredSessions(state, action: PayloadAction<Session[]>) {
-      action.payload.forEach((s) => (state.sessions[s.id] = s.toPOJO()));
+      action.payload.forEach((session) => {
+        state.sessions[session.id] = session.toPOJO();
+        updateLatestExercises(state, session);
+      });
     },
 
     addStoredSession(state, action: PayloadAction<Session>) {
       state.sessions[action.payload.id] = action.payload.toPOJO();
+      updateLatestExercises(state, action.payload);
     },
 
     deleteStoredSession(state, action: PayloadAction<string>) {
+      const deletedSession = state.sessions[action.payload];
       delete state.sessions[action.payload];
+
+      if (!deletedSession) return;
+
+      // Collect the exercise keys that were in the deleted session
+      const affectedKeys = new Set(
+        deletedSession.recordedExercises.map((e) =>
+          KeyedExerciseBlueprint.fromExerciseBlueprint(
+            fromExerciseBlueprintPOJO(e.blueprint as ExerciseBlueprintPOJO),
+          ).toString(),
+        ),
+      );
+
+      // For each affected key, clear and recalculate from remaining sessions
+      affectedKeys.forEach((key) => {
+        delete state.latestExercises[key];
+      });
+
+      Object.values(state.sessions).forEach((sessionPOJO) => {
+        updateLatestExercises(
+          state,
+          Session.fromPOJO(sessionPOJO as SessionPOJO),
+        );
+      });
     },
     updateExercise(
       state,
@@ -112,6 +148,16 @@ const storedSessionsSlice = createSlice({
   },
 
   selectors: {
+    selectLatestExercises: createSelector(
+      [(state: StoredSessionState) => state.latestExercises],
+      (exercises) =>
+        Object.fromEntries(
+          Object.entries(exercises).map(([key, exercise]) => [
+            key,
+            exercise ? fromRecordedExercisePOJO(exercise) : undefined,
+          ]),
+        ),
+    ),
     selectSessions: createSelector(
       [(state: StoredSessionState) => state.sessions],
       (sessions) => Object.values(sessions).map((x) => Session.fromPOJO(x)),
@@ -147,6 +193,26 @@ const storedSessionsSlice = createSlice({
   },
 });
 
+function updateLatestExercises(
+  state: WritableDraft<StoredSessionState>,
+  session: Session,
+) {
+  session.recordedExercises.forEach((exercise) => {
+    const key = KeyedExerciseBlueprint.fromExerciseBlueprint(
+      exercise.blueprint,
+    ).toString();
+    const latestExercise = state.latestExercises[key];
+    if (
+      !latestExercise ||
+      fromRecordedExercisePOJO(
+        latestExercise as RecordedExercisePOJO,
+      ).latestTime?.isBefore(exercise.latestTime ?? OffsetDateTime.MIN)
+    ) {
+      state.latestExercises[key] = exercise.toPOJO();
+    }
+  });
+}
+
 export const selectSessionsBy = createSelector(
   [
     storedSessionsSlice.selectors.selectSessions,
@@ -189,6 +255,7 @@ export const {
   selectCompletedDistinctSessionNames,
   selectSession,
   selectExercises,
+  selectLatestExercises,
   selectExerciseById,
 } = storedSessionsSlice.selectors;