refactor: create trash cache for optimization

Author: BlackDark

src/trash-guide.ts

@@ -5,11 +5,48 @@ import { getConfig } from "./config";
 import { logger } from "./logger";
 import { CFIDToConfigGroup, ConfigarrCF, QualityDefintionsRadarr, QualityDefintionsSonarr } from "./types/common.types";
 import { ConfigCustomFormat, ConfigQualityProfile, ConfigQualityProfileItem } from "./types/config.types";
-import { TrashArrSupported, TrashCF, TrashQP, TrashQualityDefintion } from "./types/trashguide.types";
+import { TrashArrSupported, TrashCache, TrashCF, TrashQP, TrashQualityDefintion } from "./types/trashguide.types";
 import { cloneGitRepo, loadJsonFile, mapImportCfToRequestCf, notEmpty, toCarrCF, trashRepoPaths } from "./util";
 
 const DEFAULT_TRASH_GIT_URL = "https://github.com/TRaSH-Guides/Guides";
 
+let cache: TrashCache;
+let cacheReady = false;
+
+const createCache = async () => {
+  logger.debug(`Creating TRaSH-Guides cache ...`);
+
+  const radarrCF = await loadTrashCFs("RADARR");
+  const sonarrCF = await loadTrashCFs("SONARR");
+
+  const radarrQP = await loadQPFromTrash("RADARR");
+  const sonarrQP = await loadQPFromTrash("SONARR");
+
+  const radarrQDMovie = await loadQualityDefinitionFromTrash("movie", "RADARR");
+  const sonarrQDSeries = await loadQualityDefinitionFromTrash("series", "SONARR");
+  const sonarrQDAnime = await loadQualityDefinitionFromTrash("anime", "SONARR");
+
+  cache = {
+    SONARR: {
+      qualityProfiles: sonarrQP,
+      customFormats: sonarrCF,
+      qualityDefinition: {
+        anime: sonarrQDAnime,
+        series: sonarrQDSeries,
+      },
+    },
+    RADARR: {
+      qualityProfiles: radarrQP,
+      customFormats: radarrCF,
+      qualityDefinition: {
+        movie: radarrQDMovie,
+      },
+    },
+  };
+
+  cacheReady = true;
+};
+
 export const cloneTrashRepo = async () => {
   logger.info(`Checking TRaSH-Guides repo ...`);
 
@@ -20,6 +57,7 @@ export const cloneTrashRepo = async () => {
 
   const cloneResult = await cloneGitRepo(rootPath, gitUrl, revision);
   logger.info(`TRaSH-Guides repo: ref[${cloneResult.ref}], hash[${cloneResult.hash}], path[${cloneResult.localPath}]`);
+  await createCache();
 };
 
 export const loadTrashCFs = async (arrType: TrashArrSupported): Promise<CFIDToConfigGroup> => {
@@ -29,6 +67,10 @@ export const loadTrashCFs = async (arrType: TrashArrSupported): Promise<CFIDToCo
     return new Map();
   }
 
+  if (cacheReady) {
+    return cache[arrType].customFormats;
+  }
+
   const carrIdToObject = new Map<string, { carrConfig: ConfigarrCF; requestConfig: MergedCustomFormatResource }>();
 
   let pathForFiles: string;
@@ -54,7 +96,7 @@ export const loadTrashCFs = async (arrType: TrashArrSupported): Promise<CFIDToCo
     });
   }
 
-  logger.debug(`Trash CFs: ${carrIdToObject.size}`);
+  logger.debug(`(${arrType}) Trash CFs: ${carrIdToObject.size}`);
 
   return carrIdToObject;
 };
@@ -65,6 +107,13 @@ export const loadQualityDefinitionFromTrash = async (
 ): Promise<TrashQualityDefintion> => {
   let trashPath = arrType === "RADARR" ? trashRepoPaths.radarrQualitySize : trashRepoPaths.sonarrQualitySize;
 
+  if (cacheReady) {
+    const cacheObject = cache[arrType].qualityDefinition as any;
+    if (qdType in cacheObject) {
+      return cacheObject[qdType];
+    }
+  }
+
   switch (qdType) {
     case "anime":
       return loadJsonFile(path.resolve(`${trashPath}/anime.json`));
@@ -73,21 +122,26 @@ export const loadQualityDefinitionFromTrash = async (
     case "movie":
       return loadJsonFile(path.resolve(`${trashPath}/movie.json`));
     case "custom":
-      throw new Error("Not implemented yet");
+      throw new Error(`(${arrType}) Not implemented yet`);
     default:
-      throw new Error(`Unknown QualityDefintion type: ${qdType}`);
+      throw new Error(`(${arrType}) Unknown QualityDefintion type: ${qdType}`);
   }
 };
 
 export const loadQPFromTrash = async (arrType: TrashArrSupported) => {
   let trashPath = arrType === "RADARR" ? trashRepoPaths.radarrQP : trashRepoPaths.sonarrQP;
+
+  if (cacheReady) {
+    return cache[arrType].qualityProfiles;
+  }
+
   const map = new Map<string, TrashQP>();
 
   try {
     const files = fs.readdirSync(`${trashPath}`).filter((fn) => fn.endsWith("json"));
 
     if (files.length <= 0) {
-      logger.info(`Not found any TRaSH-Guides QualityProfiles. Skipping.`);
+      logger.info(`(${arrType}) Not found any TRaSH-Guides QualityProfiles. Skipping.`);
     }
 
     for (const item of files) {
@@ -96,7 +150,7 @@ export const loadQPFromTrash = async (arrType: TrashArrSupported) => {
       map.set(importTrashQP.trash_id, importTrashQP);
     }
   } catch (err: any) {
-    logger.warn("Failed loading TRaSH-Guides QualityProfiles. Continue without ...", err?.message);
+    logger.warn(`(${arrType}) Failed loading TRaSH-Guides QualityProfiles. Continue without ...`, err?.message);
   }
 
   // const localPath = getLocalTemplatePath();
@@ -105,7 +159,7 @@ export const loadQPFromTrash = async (arrType: TrashArrSupported) => {
   //   fillMap(localPath);
   // }
 
-  logger.debug(`Found ${map.size} TRaSH-Guides QualityProfiles.`);
+  logger.debug(`(${arrType}) Found ${map.size} TRaSH-Guides QualityProfiles.`);
   return map;
 };
 

src/types/common.types.ts

@@ -82,4 +82,4 @@ const ArrTypeConst = ["RADARR", "SONARR", "WHISPARR", "READARR"] as const;
 export type ArrType = (typeof ArrTypeConst)[number];
 
 export type QualityDefintionsSonarr = "anime" | "series" | "custom";
-export type QualityDefintionsRadarr = "movie" | "custom";
+export type QualityDefintionsRadarr = "movie" | "sqp-streaming" | "sqp-uhd" | "custom";

src/types/trashguide.types.ts

@@ -1,4 +1,4 @@
-import { ArrType, ImportCF } from "./common.types";
+import { ArrType, CFIDToConfigGroup, ImportCF } from "./common.types";
 
 export type TrashQualityDefintionQuality = {
   quality: string;
@@ -72,17 +72,18 @@ export type TrashNamingFile = {
 
 export type TrashCache = {
   SONARR: {
-    qualityProfiles: TrashQP[];
-    customFormats: TrashCF[];
-    naming: TrashNamingFile;
-    cfGroups: { [key: string]: string[] };
-    qualitySize: number;
+    qualityProfiles: Map<string, TrashQP>;
+    customFormats: CFIDToConfigGroup;
+    qualityDefinition: {
+      series: TrashQualityDefintion;
+      anime: TrashQualityDefintion;
+    };
   };
   RADARR: {
-    qualityProfiles: TrashQP[];
-    customFormats: TrashCF[];
-    naming: TrashNamingFile;
-    cfGroups: { [key: string]: string[] };
-    qualitySize: number;
+    qualityProfiles: Map<string, TrashQP>;
+    customFormats: CFIDToConfigGroup;
+    qualityDefinition: {
+      movie: TrashQualityDefintion;
+    };
   };
 };