refactor: Cleanup and use finally for code simplification

Author: pgrzesik

lib/clean.js

@@ -40,7 +40,7 @@ function cleanupCache() {
   if (fse.existsSync(cacheLocation)) {
     let cleanupProgress;
     if (this.serverless) {
-      if (this.progress && this.log) {
+      if (this.log) {
         cleanupProgress = this.progress.get('python-cleanup-cache');
         cleanupProgress.notice('Removing static caches');
         this.log.info(`Removing static caches at: ${cacheLocation}`);
@@ -57,12 +57,9 @@ function cleanupCache() {
       .forEach((file) => {
         promises.push(fse.removeAsync(file));
       });
-    return BbPromise.all(promises)
-      .then(() => cleanupProgress && cleanupProgress.remove())
-      .catch((e) => {
-        cleanupProgress && cleanupProgress.remove();
-        throw e;
-      });
+    return BbPromise.all(promises).finally(
+      () => cleanupProgress && cleanupProgress.remove()
+    );
   } else {
     if (this.serverless) {
       if (this.log) {

lib/inject.js

@@ -86,7 +86,7 @@ function moveModuleUp(source, target, module) {
  * Inject requirements into packaged application.
  * @return {Promise} the combined promise for requirements injection.
  */
-function injectAllRequirements(funcArtifact) {
+async function injectAllRequirements(funcArtifact) {
   if (this.options.layer) {
     // The requirements will be placed in a Layer, so just resolve
     return BbPromise.resolve();
@@ -101,61 +101,56 @@ function injectAllRequirements(funcArtifact) {
     this.serverless.cli.log('Injecting required Python packages to package...');
   }
 
-  let returnPromise;
-  if (this.serverless.service.package.individually) {
-    returnPromise = BbPromise.resolve(this.targetFuncs)
-      .filter((func) =>
-        (func.runtime || this.serverless.service.provider.runtime).match(
-          /^python.*/
+  try {
+    if (this.serverless.service.package.individually) {
+      await BbPromise.resolve(this.targetFuncs)
+        .filter((func) =>
+          (func.runtime || this.serverless.service.provider.runtime).match(
+            /^python.*/
+          )
         )
-      )
-      .map((func) => {
-        if (!get(func, 'module')) {
-          set(func, ['module'], '.');
-        }
-        return func;
-      })
-      .map((func) => {
-        if (func.module !== '.') {
-          const artifact = func.package ? func.package.artifact : funcArtifact;
-          const newArtifact = path.join(
-            '.serverless',
-            `${func.module}-${func.name}.zip`
-          );
-          func.package.artifact = newArtifact;
-          return moveModuleUp(artifact, newArtifact, func.module).then(
-            () => func
-          );
-        } else {
+        .map((func) => {
+          if (!get(func, 'module')) {
+            set(func, ['module'], '.');
+          }
           return func;
-        }
-      })
-      .map((func) => {
-        return this.options.zip
-          ? func
-          : injectRequirements(
-              path.join('.serverless', func.module, 'requirements'),
-              func.package.artifact,
-              this.options
+        })
+        .map((func) => {
+          if (func.module !== '.') {
+            const artifact = func.package
+              ? func.package.artifact
+              : funcArtifact;
+            const newArtifact = path.join(
+              '.serverless',
+              `${func.module}-${func.name}.zip`
             );
-      });
-  } else if (!this.options.zip) {
-    returnPromise = injectRequirements(
-      path.join('.serverless', 'requirements'),
-      this.serverless.service.package.artifact || funcArtifact,
-      this.options
-    );
+            func.package.artifact = newArtifact;
+            return moveModuleUp(artifact, newArtifact, func.module).then(
+              () => func
+            );
+          } else {
+            return func;
+          }
+        })
+        .map((func) => {
+          return this.options.zip
+            ? func
+            : injectRequirements(
+                path.join('.serverless', func.module, 'requirements'),
+                func.package.artifact,
+                this.options
+              );
+        });
+    } else if (!this.options.zip) {
+      await injectRequirements(
+        path.join('.serverless', 'requirements'),
+        this.serverless.service.package.artifact || funcArtifact,
+        this.options
+      );
+    }
+  } finally {
+    injectProgress && injectProgress.remove();
   }
-
-  return (
-    returnPromise &&
-    returnPromise
-      .then(() => injectProgress && injectProgress.remove())
-      .catch((e) => {
-        injectProgress && injectProgress.remove();
-        throw e;
-      })
-  );
 }
 
 module.exports = { injectAllRequirements };

lib/layer.js

@@ -65,11 +65,7 @@ function layerRequirements() {
   return BbPromise.bind(this)
     .then(zipRequirements)
     .then(createLayers)
-    .then(() => layerProgress && layerProgress.remove())
-    .catch((e) => {
-      layerProgress && layerProgress.remove();
-      throw e;
-    });
+    .finally(() => layerProgress && layerProgress.remove());
 }
 
 module.exports = {

lib/zip.js

@@ -139,11 +139,7 @@ function packRequirements() {
           f.package.patterns.push(`${f.module}/.requirements.zip`);
           return addTree(new JSZip(), `.serverless/${f.module}/requirements`)
             .then((zip) => writeZip(zip, `${f.module}/.requirements.zip`))
-            .then(() => packProgress && packProgress.remove())
-            .catch((e) => {
-              packProgress && packProgress.remove();
-              throw e;
-            });
+            .finally(() => packProgress && packProgress.remove());
         });
     } else {
       let packProgress;