🔧 Refactoring still.

src/server/interfaces/folder.interface.ts

@@ -24,7 +24,7 @@ export interface IFolderData {
 
 export interface IExplodedPathResponse {
   exploded: Array<string>;
-  fileName: string | Array<string>;
+  fileName: string;
 }
 
 export interface IComicBookCoverMetadata {

src/server/route/routes/importComics.routes.ts

@@ -11,13 +11,14 @@ import {
 import { Request, Response } from "express";
 
 router.route("/getComicCovers").get(async (req: Request, res: Response) => {
-  const foo = await extractArchive({
+  const options = {
-    name: "Ozymandias 001.cbr",
+    name: "Gyo v01 (2003) (Digital) (LostNerevarine-Empire)",
-    extension: ".cbr",
+    extension: ".cbz",
-    containedIn: "comics/(2012) Before Watchmen - Ozymandias",
+    containedIn: "comics/ITOU Junji - Gyo",
     isFile: true,
     isLink: false,
-  });
+  };
+  const foo = await extractArchive(options);
   // const foo = await extractMetadataFromImage(
   //   "./comics/covers/Ghosts and Ruins-001.jpg",
   // );

src/server/utils/fs.utils.ts

@@ -34,6 +34,16 @@ export const unrar = async (
       extractionOptions.folderDetails.name,
   ).catch((err) => console.error("Failed to read file", err));
 
+  const targetPath =
+    extractionTargetPath + "/" + extractionOptions.folderDetails.name;
+
+  try {
+    await fse.ensureDir(targetPath, directoryOptions);
+    logger.info(`${targetPath} was created or already exists.`);
+  } catch (error) {
+    logger.error(`${error}: Couldn't create directory.`);
+  }
+
   const extractor = await unrarer.createExtractorFromData({ data: fileBuffer });
   switch (extractionOptions.extractTarget) {
     case "cover":
@@ -43,32 +53,22 @@ export const unrar = async (
 
       const extractedFile = [...file.files][0];
       const fileArrayBuffer = extractedFile.extraction;
-      const pathFragments = explodePath(extractedFile.fileHeader.name);
-      const targetPath =
-        extractionTargetPath + "/" + pathFragments.exploded.join("/");
 
       logger.info(`Attempting to write ${extractedFile.fileHeader.name}`);
 
       return new Promise(async (resolve, reject) => {
         try {
-          await fse.ensureDir(targetPath, directoryOptions);
+          const fileName = explodePath(extractedFile.fileHeader.name).fileName;
-          logger.info(`${targetPath} was created or already exists.`);
+          if (fileName !== "") {
-          try {
+            await writeFile(targetPath + "/" + fileName, fileArrayBuffer);
-            await writeFile(
-              targetPath + "/" + pathFragments.fileName,
-              fileArrayBuffer,
-            );
-            resolve({
-              name: `${extractedFile.fileHeader.name}`,
-              path: targetPath,
-              fileSize: extractedFile.fileHeader.packSize,
-            });
-          } catch (error) {
-            logger.error(`${error}: Couldn't write file.`);
-            reject(error);
           }
+          resolve({
+            name: `${extractedFile.fileHeader.name}`,
+            path: targetPath,
+            fileSize: extractedFile.fileHeader.packSize,
+          });
         } catch (error) {
-          logger.error(`${error}: Coudln't create directory.`);
+          logger.error(`${error}: Couldn't write file.`);
           reject(error);
         }
       });
@@ -81,29 +81,19 @@ export const unrar = async (
         for (const file of extractedFiles) {
           logger.info(`Attempting to write ${file.fileHeader.name}`);
           const fileBuffer = file.extraction;
-          const pathFragments = explodePath(file.fileHeader.name);
+          const fileName = explodePath(file.fileHeader.name).fileName;
-          const fragment = determineFolderNameForExtraction(pathFragments);
-          const targetPath = extractionTargetPath + "/" + fragment;
           try {
-            await fse.ensureDir(targetPath, directoryOptions);
+            if (fileName !== "") {
-            logger.info(`${targetPath} was created or already exists.`);
+              await writeFile(targetPath + "/" + fileName, fileBuffer);
-            try {
-              await writeFile(
-                targetPath + "/" + pathFragments.fileName,
-                fileBuffer,
-              );
-              comicBookCoverFiles.push({
-                name: `${file.fileHeader.name}`,
-                path: targetPath,
-                fileSize: file.fileHeader.packSize,
-              });
-            } catch (error) {
-              logger.error(error);
-              reject(error);
             }
-          } catch (err) {
+            comicBookCoverFiles.push({
-            logger.error(err);
+              name: `${file.fileHeader.name}`,
-            reject(err);
+              path: targetPath,
+              fileSize: file.fileHeader.packSize,
+            });
+          } catch (error) {
+            logger.error(error);
+            reject(error);
           }
         }
         resolve(comicBookCoverFiles);
@@ -140,34 +130,47 @@ export const unzip = async (
   const targetPath =
     extractionOptions.sourceFolder +
     "/" +
-    extractionOptions.targetExtractionFolder;
+    extractionOptions.targetExtractionFolder +
+    "/" +
+    extractionOptions.folderDetails.name;
+
   const zip = createReadStream(
-    extractionOptions.sourceFolder + "/" + extractionOptions.folderDetails.name,
+    extractionOptions.folderDetails.containedIn +
+      "/" +
+      extractionOptions.folderDetails.name +
+      extractionOptions.folderDetails.extension,
   ).pipe(unzipper.Parse({ forceStream: true }));
-  for await (const entry of zip) {
+
-    try {
+  try {
-      await fse.ensureDir(targetPath, directoryOptions);
+    await fse.ensureDir(targetPath, directoryOptions);
-      logger.info(`${targetPath} was created or already exists.`);
+    logger.info(`${targetPath} was created or already exists.`);
-      const fileName = entry.path;
+    for await (const entry of zip) {
+      const fileName = explodePath(entry.path).fileName;
       const size = entry.vars.uncompressedSize; // There is also compressedSize;
+
+      if (fileName !== "") {
+        entry.pipe(createWriteStream(targetPath + "/" + fileName));
+      }
       extractedFiles.push({
         name: fileName,
         fileSize: size,
         path: targetPath,
       });
-      entry.pipe(createWriteStream(targetPath + fileName));
       entry.autodrain();
-    } catch (error) {
-      logger.error(`${error} Couldn't create directory.`);
     }
+  } catch (error) {
+    logger.error(`${error} Couldn't create directory.`);
   }
-  return new Promise((resolve, reject) => {
+
+  return new Promise(async (resolve, reject) => {
     logger.info("");
     resolve(extractedFiles);
   });
 };
 
-export const unzipOne = async (): Promise<IExtractedComicBookCoverFile> => {
+export const unzipOne = async (
+  extractionOptions: IExtractionOptions,
+): Promise<IExtractedComicBookCoverFile> => {
   const directory = await unzipper.Open.file(
     "./comics/Lovecraft - The Myth of Cthulhu (2018) (Maroto) (fylgja).cbz",
   );
@@ -193,11 +196,11 @@ export const extractArchive = async (
   | IExtractedComicBookCoverFile[]
   | IExtractComicBookCoverErrorResponse
 > => {
-  const sourceFolder = "./comics/";
+  const sourceFolder = "./comics";
   const targetExtractionFolder = "expanded";
   const extractionOptions: IExtractionOptions = {
     folderDetails: fileObject,
-    extractTarget: "all",
+    extractTarget: "cover",
     sourceFolder,
     targetExtractionFolder,
   };
@@ -241,19 +244,13 @@ export const explodePath = (filePath: string): IExplodedPathResponse => {
   const exploded = filePath.split("/");
   const fileName = _.remove(exploded, (item) => {
     return _.indexOf(exploded, item) === exploded.length - 1;
+  }).join("");
+  console.log({
+    exploded,
+    fileName,
   });
   return {
     exploded,
     fileName,
   };
 };
-
-export const determineFolderNameForExtraction = (
-  pathFragments: IExplodedPathResponse,
-): string | string[] => {
-  if (pathFragments.exploded.length === 0) {
-    return pathFragments.fileName;
-  } else {
-    return pathFragments.exploded.join("/");
-  }
-};