Add multiple methods to MusicBrainz class and caching to the poster request methods

server/api/musicbrainz/index.ts

@@ -485,6 +485,39 @@ class MusicBrainz extends BaseNodeBrainz {
     }
   };
 
+  public getFullArtist = (artistId: string): Promise<mbArtist> => {
+    try {
+      return new Promise<mbArtist>((resolve, reject) => {
+        this.artist(
+          artistId,
+          {
+            inc: 'tags',
+          },
+          async (error, data) => {
+            if (error) {
+              reject(error);
+            } else {
+              const results = convertArtist(data as Artist);
+              results.releaseGroups = await this.getReleaseGroups(artistId);
+              /*
+              results.releases = await this.getReleases(artistId);
+              results.recordings = await this.getRecordings(artistId);
+              results.works = await this.getWorks(artistId);
+              */
+              resolve(results);
+            }
+          }
+        );
+      });
+    } catch (e) {
+      logger.error('Failed to get full artist', {
+        label: 'MusicBrainz',
+        message: e.message,
+      });
+      return new Promise<mbArtist>((resolve) => resolve({} as mbArtist));
+    }
+  };
+
   public getRecording = (recordingId: string): Promise<mbRecording> => {
     try {
       return new Promise<mbRecording>((resolve, reject) => {
@@ -512,6 +545,64 @@ class MusicBrainz extends BaseNodeBrainz {
     }
   };
 
+  public getReleaseGroups = (artistId: string): Promise<mbReleaseGroup[]> => {
+    try {
+      return new Promise<mbReleaseGroup[]>((resolve, reject) => {
+        this.browse(
+          'release-group',
+          { artist: artistId },
+          async (error, data) => {
+            if (error) {
+              reject(error);
+            } else {
+              const results = await new Promise<mbReleaseGroup[]>(
+                (resolve2, reject2) => {
+                  this.browse(
+                    'release-group',
+                    {
+                      artist: artistId,
+                      limit:
+                        (
+                          data as {
+                            'release-group-count': number;
+                            'release-group-offset': number;
+                            'release-groups': Group[];
+                          }
+                        )['release-group-count'] ?? 25,
+                    },
+                    (error, data) => {
+                      if (error) {
+                        reject2(error);
+                      } else {
+                        const results = (
+                          (
+                            data as {
+                              'release-group-count': number;
+                              'release-group-offset': number;
+                              'release-groups': Group[];
+                            }
+                          )['release-groups'] ?? []
+                        ).map(convertReleaseGroup);
+                        resolve2(results);
+                      }
+                    }
+                  );
+                }
+              );
+              resolve(results);
+            }
+          }
+        );
+      });
+    } catch (e) {
+      logger.error('Failed to get release-groups by artist', {
+        label: 'MusicBrainz',
+        message: e.message,
+      });
+      return new Promise<mbReleaseGroup[]>((resolve) => resolve([]));
+    }
+  };
+
   public getReleaseGroup = (
     releaseGroupId: string
   ): Promise<mbReleaseGroup> => {

server/api/musicbrainz/poster.ts

@@ -50,5 +50,19 @@ async function getFanartFromMB(element: mbArtist): Promise<string | undefined> {
   }
 }
 
-export default getPosterFromMB;
-export { getFanartFromMB };
+const memoize = <T = unknown>(fn: (...val: T[]) => unknown) => {
+  const cache = new Map();
+  const cached = function (this: unknown, val: T) {
+    return cache.has(val)
+      ? cache.get(val)
+      : cache.set(val, fn.call(this, val) as ReturnType<typeof fn>) &&
+          cache.get(val);
+  };
+  cached.cache = cache;
+  return cached;
+};
+
+const cachedFanartFromMB = memoize(getFanartFromMB);
+
+export default memoize(getPosterFromMB);
+export { cachedFanartFromMB };