Refactor skill management in RoomResource to improve event handling and caching

Author: lukemelia

packages/host/app/resources/room.ts

@@ -48,12 +48,6 @@ import type CardService from '../services/card-service';
 import type CommandService from '../services/command-service';
 import type MatrixService from '../services/matrix-service';
 
-interface SkillId {
-  skillCardId: string;
-  skillEventId: string;
-  isActive: boolean;
-}
-
 interface Args {
   named: {
     roomId: string | undefined;
@@ -64,6 +58,8 @@ interface Args {
 export class RoomResource extends Resource<Args> {
   private _messageCache: TrackedMap<string, Message> = new TrackedMap();
   private _skillCardsCache: TrackedMap<string, SkillCard> = new TrackedMap();
+  private _skillEventIdToCardIdCache: TrackedMap<string, string> =
+    new TrackedMap();
   private _nameEventsCache: TrackedMap<string, RoomNameEvent> =
     new TrackedMap();
   @tracked private _createEvent: RoomCreateEvent | undefined;
@@ -196,61 +192,38 @@ export class RoomResource extends Resource<Args> {
     return this.events.sort((a, b) => a.origin_server_ts - b.origin_server_ts);
   }
 
-  @cached
-  get skillIds(): SkillId[] {
+  private get allSkillEventIds(): Set<string> {
     let skillsConfig = this.matrixRoom?.skillsConfig;
     if (!skillsConfig) {
-      return [];
+      return new Set();
     }
-    let result: SkillId[] = [];
-    for (let eventId of [
+    return new Set([
       ...skillsConfig.enabledEventIds,
       ...skillsConfig.disabledEventIds,
-    ]) {
-      let cardDoc;
-      try {
-        cardDoc = this.serializedCardFromFragments(eventId);
-      } catch {
-        // the skill card fragments might not be loaded yet
+    ]);
+  }
+
+  get skills(): Skill[] {
+    let result: Skill[] = [];
+    for (let skillEventId of this.allSkillEventIds) {
+      let cardId = this._skillEventIdToCardIdCache.get(skillEventId);
+      if (!cardId) {
         continue;
       }
-      if (!cardDoc.data.id) {
+      let skillCard = this._skillCardsCache.get(cardId);
+      if (!skillCard) {
         continue;
       }
-      let cardId = cardDoc.data.id;
-      if (!this._skillCardsCache.has(cardId)) {
-        this.cardService
-          .createFromSerialized(cardDoc.data, cardDoc)
-          .then((skillsCard) => {
-            this._skillCardsCache.set(cardId, skillsCard as SkillCard);
-          });
-      }
       result.push({
-        skillCardId: cardDoc.data.id,
-        skillEventId: eventId,
-        isActive: skillsConfig.enabledEventIds.includes(eventId),
+        card: skillCard,
+        skillEventId,
+        isActive:
+          this.matrixRoom?.skillsConfig.enabledEventIds.includes(skillEventId),
       });
     }
     return result;
   }
 
-  @cached
-  get skills(): Skill[] {
-    return this.skillIds
-      .map(({ skillCardId, skillEventId, isActive }) => {
-        let card = this._skillCardsCache.get(skillCardId);
-        if (card) {
-          return {
-            card,
-            skillEventId,
-            isActive,
-          };
-        }
-        return null;
-      })
-      .filter(Boolean) as Skill[];
-  }
-
   @cached
   get created() {
     if (this._createEvent) {
@@ -348,6 +321,34 @@ export class RoomResource extends Resource<Args> {
   ) {
     let eventId = event.event_id;
     this._fragmentCache.set(eventId, event.content);
+
+    if (this.isSkillEventId(eventId)) {
+      await this.ensureSkillCardCached(eventId);
+    }
+  }
+
+  private isSkillEventId(eventId: string) {
+    return this.allSkillEventIds.has(eventId);
+  }
+
+  private async ensureSkillCardCached(eventId: string) {
+    if (this._skillEventIdToCardIdCache.has(eventId)) {
+      return;
+    }
+    let cardDoc = this.serializedCardFromFragments(eventId);
+    if (!cardDoc.data.id) {
+      console.warn(
+        `No card id found for skill event id ${eventId}, this should not happen, this can happen if you add a skill card to a room without saving it, and without giving it an ID`,
+      );
+      return;
+    }
+    let cardId = cardDoc.data.id;
+    let skillCard = (await this.cardService.createFromSerialized(
+      cardDoc.data,
+      cardDoc,
+    )) as SkillCard;
+    this._skillCardsCache.set(cardId, skillCard);
+    this._skillEventIdToCardIdCache.set(eventId, cardId);
   }
 
   private loadRoomMessage({