refactor: move merge config to config.ts

Author: BlackDark

src/config.ts

@@ -1,11 +1,17 @@
 import { existsSync, readFileSync } from "node:fs";
 import yaml from "yaml";
 import { getHelpers } from "./env";
+import { loadLocalRecyclarrTemplate } from "./local-importer";
 import { logger } from "./logger";
+import { filterInvalidQualityProfiles } from "./quality-profiles";
+import { loadRecyclarrTemplates } from "./recyclarr-importer";
+import { loadQPFromTrash, transformTrashQPCFs, transformTrashQPToTemplate } from "./trash-guide";
+import { ArrType, MappedMergedTemplates } from "./types/common.types";
 import {
   ConfigArrInstance,
   ConfigCustomFormat,
   ConfigIncludeItem,
+  ConfigQualityProfile,
   ConfigSchema,
   InputConfigArrInstance,
   InputConfigIncludeItem,
@@ -151,3 +157,215 @@ export const validateConfig = (input: InputConfigInstance): MergedConfigInstance
     })),
   };
 };
+
+/**
+ * Load data from trash, recyclarr, custom configs and merge.
+ * Afterwards do sanitize and check against required configuration.
+ * @param value
+ * @param arrType
+ */
+export const mergeConfigsAndTemplates = async (
+  value: InputConfigArrInstance,
+  arrType: ArrType,
+): Promise<{ config: MergedConfigInstance }> => {
+  const recyclarrTemplateMap = loadRecyclarrTemplates(arrType);
+  const localTemplateMap = loadLocalRecyclarrTemplate(arrType);
+  const trashTemplates = await loadQPFromTrash(arrType);
+
+  logger.debug(
+    `Loaded ${recyclarrTemplateMap.size} Recyclarr templates, ${localTemplateMap.size} local templates and ${trashTemplates.size} trash templates.`,
+  );
+
+  const recyclarrMergedTemplates: MappedMergedTemplates = {
+    custom_formats: [],
+    quality_profiles: [],
+  };
+
+  // HINT: we assume customFormatDefinitions only exist in RECYCLARR
+  if (value.include) {
+    const mappedIncludes = value.include.reduce<{ recyclarr: InputConfigIncludeItem[]; trash: InputConfigIncludeItem[] }>(
+      (previous, current) => {
+        switch (current.source) {
+          case "TRASH":
+            previous.trash.push(current);
+            break;
+          case "RECYCLARR":
+            previous.recyclarr.push(current);
+            break;
+          default:
+            logger.warn(`Unknown type for template requested: ${(current as any).type}. Ignoring.`);
+        }
+
+        return previous;
+      },
+      { recyclarr: [], trash: [] },
+    );
+
+    logger.info(
+      `Found ${value.include.length} templates to include. Mapped to [recyclarr]=${mappedIncludes.recyclarr.length}, [trash]=${mappedIncludes.trash.length} ...`,
+    );
+
+    mappedIncludes.recyclarr.forEach((e) => {
+      const template = recyclarrTemplateMap.get(e.template) ?? localTemplateMap.get(e.template);
+
+      if (!template) {
+        logger.warn(`Unknown recyclarr template requested: ${e.template}`);
+        return;
+      }
+
+      if (template.custom_formats) {
+        recyclarrMergedTemplates.custom_formats?.push(...template.custom_formats);
+      }
+
+      if (template.quality_definition) {
+        recyclarrMergedTemplates.quality_definition = template.quality_definition;
+      }
+
+      if (template.quality_profiles) {
+        for (const qp of template.quality_profiles) {
+          recyclarrMergedTemplates.quality_profiles.push(qp);
+        }
+      }
+
+      if (template.media_management) {
+        recyclarrMergedTemplates.media_management = { ...recyclarrMergedTemplates.media_management, ...template.media_management };
+      }
+
+      if (template.media_naming) {
+        recyclarrMergedTemplates.media_naming = { ...recyclarrMergedTemplates.media_naming, ...template.media_naming };
+      }
+
+      if (template.customFormatDefinitions) {
+        if (Array.isArray(template.customFormatDefinitions)) {
+          recyclarrMergedTemplates.customFormatDefinitions = [
+            ...(recyclarrMergedTemplates.customFormatDefinitions || []),
+            ...template.customFormatDefinitions,
+          ];
+        } else {
+          logger.warn(`CustomFormatDefinitions in template must be an array. Ignoring.`);
+        }
+      }
+
+      // TODO Ignore recursive include for now
+      if (template.include) {
+        logger.warn(`Recursive includes not supported at the moment. Ignoring.`);
+      }
+    });
+
+    // TODO: local TRaSH-Guides QP templates do not work yet
+    mappedIncludes.trash.forEach((e) => {
+      const template = trashTemplates.get(e.template);
+
+      if (!template) {
+        logger.warn(`Unknown trash template requested: ${e.template}`);
+        return;
+      }
+
+      recyclarrMergedTemplates.quality_profiles.push(transformTrashQPToTemplate(template));
+      recyclarrMergedTemplates.custom_formats.push(transformTrashQPCFs(template));
+    });
+  }
+
+  // Config values overwrite template values
+  if (value.custom_formats) {
+    recyclarrMergedTemplates.custom_formats.push(...value.custom_formats);
+  }
+
+  if (value.quality_profiles) {
+    recyclarrMergedTemplates.quality_profiles.push(...value.quality_profiles);
+  }
+
+  if (value.media_management) {
+    recyclarrMergedTemplates.media_management = { ...recyclarrMergedTemplates.media_management, ...value.media_management };
+  }
+
+  if (value.media_naming) {
+    recyclarrMergedTemplates.media_naming = { ...recyclarrMergedTemplates.media_naming, ...value.media_naming };
+  }
+
+  if (value.quality_definition) {
+    recyclarrMergedTemplates.quality_definition = { ...recyclarrMergedTemplates.quality_definition, ...value.quality_definition };
+  }
+
+  if (value.customFormatDefinitions) {
+    if (Array.isArray(value.customFormatDefinitions)) {
+      recyclarrMergedTemplates.customFormatDefinitions = [
+        ...(recyclarrMergedTemplates.customFormatDefinitions || []),
+        ...value.customFormatDefinitions,
+      ];
+    } else {
+      logger.warn(`CustomFormatDefinitions in config file must be an array. Ignoring.`);
+    }
+  }
+
+  const recyclarrProfilesMerged = recyclarrMergedTemplates.quality_profiles.reduce<Map<string, ConfigQualityProfile>>((p, c) => {
+    const profile = p.get(c.name);
+
+    if (profile == null) {
+      p.set(c.name, c);
+    } else {
+      p.set(c.name, {
+        ...profile,
+        ...c,
+        reset_unmatched_scores: {
+          enabled: c.reset_unmatched_scores?.enabled ?? profile.reset_unmatched_scores?.enabled ?? true,
+          except: c.reset_unmatched_scores?.except ?? profile.reset_unmatched_scores?.except,
+        },
+        upgrade: {
+          ...profile.upgrade,
+          ...c.upgrade,
+        },
+      });
+    }
+
+    return p;
+  }, new Map());
+
+  recyclarrMergedTemplates.quality_profiles = Array.from(recyclarrProfilesMerged.values());
+
+  recyclarrMergedTemplates.quality_profiles = filterInvalidQualityProfiles(recyclarrMergedTemplates.quality_profiles);
+
+  // merge profiles from recyclarr templates into one
+  const qualityProfilesMerged = recyclarrMergedTemplates.quality_profiles.reduce((p, c) => {
+    let existingQp = p.get(c.name);
+
+    if (!existingQp) {
+      p.set(c.name, { ...c });
+    } else {
+      existingQp = {
+        ...existingQp,
+        ...c,
+        // Overwriting qualities array for now
+        upgrade: { ...existingQp.upgrade, ...c.upgrade },
+        reset_unmatched_scores: {
+          ...existingQp.reset_unmatched_scores,
+          ...c.reset_unmatched_scores,
+          enabled: (c.reset_unmatched_scores?.enabled ?? existingQp.reset_unmatched_scores?.enabled) || false,
+        },
+      };
+      p.set(c.name, existingQp);
+    }
+
+    return p;
+  }, new Map<string, ConfigQualityProfile>());
+
+  recyclarrMergedTemplates.quality_profiles = Array.from(qualityProfilesMerged.values());
+
+  const validatedConfig = validateConfig(recyclarrMergedTemplates);
+  logger.debug(`Merged config: '${JSON.stringify(validatedConfig)}'`);
+
+  /*
+  TODO: do we want to load all available local templates or only the included ones in the instance?
+  Example: we have a local template folder which we can always traverse. So we could load every CF defined there.
+  But then we could also have in theory conflicted CF IDs if user want to define same CF in different templates.
+  How to handle overwrite? Maybe also support overriding CFs defined in Trash or something?
+  */
+  // const localTemplateCFDs = Array.from(localTemplateMap.values()).reduce((p, c) => {
+  //   if (c.customFormatDefinitions) {
+  //     p.push(...c.customFormatDefinitions);
+  //   }
+  //   return p;
+  // }, [] as CustomFormatDefinitions);
+
+  return { config: validatedConfig };
+};