fix: zipper performance and bug fixes

Author: hmdoganjf

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jotforminc/zenith",
   "packageManager": "pnpm@7.18.0",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "",
   "main": "./build/index.js",
   "files": [

src/classes/Cache/Cacher.ts

@@ -76,33 +76,26 @@ export default abstract class Cacher {
     });
   }
 
-  cacheZip(cachePath: string, output: string, directoryPath: string) {
-    return new Promise<void>((resolve, reject) => {
-      Zipper.zip(directoryPath, (error: Error | null, zipped: ZipExporter) => {
-        if (error) {
-          Logger.log(2, 'ERROR => ', error);
-          reject(error);
-          return;
+  async cacheZip(cachePath: string, output: string, directoryPath: string) {
+    await Zipper.zip(directoryPath, (error: Error | null, zipped: ZipExporter) => {
+      if (error) {
+        Logger.log(2, 'ERROR CZ-1 => ', error);
+        return;
+      }
+      zipped.compress();
+      zipped.memory().then((buff) => {
+        if (buff instanceof Buffer) {
+          this.putObject({
+            Key: `${cachePath}/${output}.zip`,
+            Body: buff
+          }).then(() => {
+            Logger.log(3, 'Zip Cache successfully stored');
+          }).catch((err) => {
+            Logger.log(2, err);
+          });
         }
-        zipped.compress();
-        zipped.memory().then((buff) => {
-          if (buff instanceof Buffer) {
-            this.putObject(
-              {
-                Key: `${cachePath}/${output}.zip`,
-                Body: buff
-              }).then(() => {
-                Logger.log(3, 'Zip Cache successfully stored');
-                resolve();
-              }).catch((err) => {
-                Logger.log(2, err);
-                reject(err);
-              });
-          }
-        }).catch((err) => {
-          Logger.log(2, err);
-          reject(err);
-        });
+      }).catch((err) => {
+        Logger.log(2, err);
       });
     });
   }

src/classes/Zipper.js

@@ -3,112 +3,87 @@ import fs from 'fs';
 import path from 'path';
 import JSZip from 'jszip';
 import ZipExporter from '../libs/zipExporter';
-import UnzippedReader from '../libs/UnzippedReader';
-import { Readable } from 'stream';
 
 JSZip.make = () => {
-    const augment = (_opts) => {
-        const opts = _opts || {};
-        opts.createFolders = opts.createFolders || true;
-        return opts;
-    }
+  const augment = (_opts) => {
+    const opts = _opts || {};
+    opts.createFolders = opts.createFolders || true;
+    return opts;
+  };
 
-    const instance = new JSZip();
-    const originals = {
-        loadAsync: instance.loadAsync,
-        file: instance.file,
-    };
+  const instance = new JSZip();
+  const originals = {
+    loadAsync: instance.loadAsync,
+    file: instance.file,
+  };
 
-    instance.loadAsync = (data, options) => {
-        return originals.loadAsync.call(instance, data, augment(options));
-    };
+  instance.loadAsync = (data, options) => {
+    return originals.loadAsync.call(instance, data, augment(options));
+  };
 
-    instance.file = (name, content, options) => {
-        if (!content) {
-            return originals.file.call(instance, name);
-        }
-        return originals.file.call(instance, name, content, augment(options));
-    };
-    return instance;
+  instance.file = (name, content, options) => {
+    if (!content) {
+      return originals.file.call(instance, name);
+    }
+    return originals.file.call(instance, name, content, augment(options));
+  };
+  return instance;
 };
 
 const zipDir = async (dir, zippedDir) => {
-    return new Promise((resolve, reject) => {
-        fs.readdir(dir, (err, files) => {
-            if (err) {
-                reject(err);
-            }
-            const filePaths = files.map(file => path.join(dir, file));
-            const typedFiles = filePaths.reduce((acc, filePath) => {
-                const stats = fs.statSync(filePath);
-                acc.push({
-                    path: filePath,
-                    isDirectory: stats.isDirectory() ? 'dir' : 'file',
-                });
-                return acc;
-            }, []);
-            for (const entry of typedFiles) {
-                const parsedEntryPath = path.parse(entry.path);
-                if (entry.type === 'dir') {
-                    const newZippedDir = zippedDir.folder(parsedEntryPath.base);
-                    zipDir(entry.path, newZippedDir).then(console.log);
-                }
-                else {
-                    fs.readFile(entry.path, (err, data) => {
-                        if (err) {
-                            reject(err);
-                        }
-                        zippedDir.file(parsedEntryPath.base, data);
-                    });
-                }
-            }
-            resolve();
-        });
+  const files = await fs.promises.readdir(dir);
+  const filePaths = files.map(file => path.join(dir, file));
+  const typedFiles = [];
+  for (const filePath of filePaths) {
+    const stats = await fs.promises.stat(filePath);
+    typedFiles.push({
+      path: filePath,
+      type: stats.isDirectory() ? 'dir' : 'file',
     });
-}
-
-const zipDirSync = (dir, zippedDir) => {
-    const entries = fs.readdirSync(dir);
-
-    for (const entry of entries) {
-        const entryNormalizedPath = path.normalize(path.join(dir, entry));
-        const stats = fs.statSync(entryNormalizedPath);
-        if (stats.isDirectory()) {
-            const newZippedDir = zippedDir.folder(entry);
-            zipDirSync(entryNormalizedPath, newZippedDir);
-        }
-        else {
-            const data = fs.readFileSync(entryNormalizedPath);
-            zippedDir.file(entry, data);
-        }
+  }
+  for (const entry of typedFiles) {
+    const parsedEntryPath = path.parse(entry.path);
+    if (entry.type === 'dir') {
+      zippedDir.folder(parsedEntryPath.base);
+      await zipDir(entry.path, zippedDir);
     }
-    return zippedDir;
-}
+    else {
+      const data = await fs.promises.readFile(entry.path);
+      zippedDir.file(parsedEntryPath.base, data.toString());
+    }
+  }
+};
 
 const Zipper = {};
 
-Zipper.zip = (entity, _callback, _shiftedCallback) => {
-    const zippedObj = JSZip.make();
-    if (entity instanceof Buffer) {
-        // entity is a buffer containing a file, _callback is the name of the buffer
-        const callback = _shiftedCallback || (() => {});
-        zippedObj.file(_callback, entity);
-        callback(null, new ZipExporter(zippedObj, false, true));
-    }
-    else if (entity instanceof UnzippedReader) {
-        // entity is an unzipped file
-        const callback = _callback || (() => {});
-        callback(null, new ZipExporter(entity.unzipped_file, false, true));
+Zipper.zip = async (entity, _callback, _shiftedCallback) => {
+  const zippedObj = JSZip.make();
+  if (typeof entity === 'string') {
+    // entity is a path to a file/directory
+    const callback = _callback || (() => {});
+    const normalizedPath = path.normalize(entity);
+    const stats = await fs.promises.stat(normalizedPath);
+    if (stats.isDirectory()) {
+      await zipDir(normalizedPath, zippedObj);
+      callback(null, new ZipExporter(zippedObj, false, true));
+      return;
     }
     else {
-        _callback(new Error('Invalid entity type'));
+      const parsedPath = path.parse(normalizedPath);
+      const data = await fs.promises.readFile(normalizedPath);
+      zippedObj.file(parsedPath.base, data);
+      callback(null, new ZipExporter(zippedObj, false, true));
     }
+  }
+  else {
+    _callback(new Error('Invalid entity type'));
+  }
 };
 
 Zipper.unzip = async (entity) => {
-    const zippedObj = JSZip.make();
-    await zippedObj.loadAsync(entity);
-    return new ZipExporter(zippedObj, true, true);
-}
+  const zippedObj = JSZip.make();
+  await zippedObj.loadAsync(entity);
+  return new ZipExporter(zippedObj, true, true);
+};
 
-export default Zipper;
+export default Zipper;