@eui/tools 5.0.0-rc.1 → 5.0.0-rc.13

package/scripts/csdr/metadata/common.js

@@ -7,7 +7,6 @@ const path = require('path');
 const tools = require('../../utils/tools');
 const gitUtils = require('../../utils/git-utils');
 const configUtils = require('../config/config-utils');
-const confluenceUtils = require('../../utils/confluence-utils');
 
 // fetching command parameters
 const { dryRun, skipClone } = tools.getArgs();
@@ -38,6 +37,27 @@ module.exports.cloneMetadataRepo = () => {
 }
 
 
+module.exports.cloneMetadataLocksRepo = () => {
+  const configOptions = configUtils.global.getConfigOptions();
+
+  tools.logTitle('Cloning devops metadata locks repo');
+
+  if (dryRun || skipClone) {
+    tools.logInfo('DRY-RUN: cloning skipped');
+    return Promise.resolve();
+
+  } else {
+    return Promise.resolve()
+      .then(() => {
+        return gitUtils.cloneRepo(configOptions.DEVOPS_METADATA_LOCKS_REPOSITORY, configOptions.DEVOPS_METADATA_LOCKS_PATH, false, true);
+      })
+      .catch((e) => {
+        throw e;
+      })
+  }
+}
+
+
 module.exports.getDevopsMetadata = () => {
   const configOptions = configUtils.global.getConfigOptions();
   const DEVOPS_METADATA_PATH = configOptions.DEVOPS_METADATA_PATH;
@@ -143,47 +163,3 @@ module.exports.isSonarEnabled = () => {
     throw e;
   })
 }
-
-module.exports.publishMetadata = (project) => {
-  var envsTableContent;
-  var historyTableContent;
-
-  if (!project.confluencePageId) {
-    tools.logWarning(`WARNING - project ${project.name} has NO Confluence page id defined`);
-
-  } else {
-
-    return Promise.resolve()
-
-      // generate history metadata table
-      .then(() => {
-        return innerAppHistory.getMetadata(project);
-      })
-      .then((historyMetadata) => {
-        return innerAppHistory.historyMetadataToTable(historyMetadata);
-      })
-      .then((tableContent) => {
-        historyTableContent = tableContent;
-      })
-
-      // generate envs metadata table
-      .then(() => {
-        return innerAppEnvs.getMetadata(project);
-      })
-      .then((envsMetadata) => {
-        return innerAppEnvs.envsMetadataToTable(envsMetadata);
-      })
-      .then((tableContent) => {
-        envsTableContent = tableContent;
-      })
-
-      .then(() => {
-        if (envsTableContent !== '' || historyTableContent !== '') {
-          return confluenceUtils.updatePageContent(project.confluencePageId, envsTableContent + '\n' + historyTableContent);
-        }
-      })
-      .catch((e) => {
-        throw e;
-      })
-  }
-}

package/scripts/csdr/metadata/metadata-utils.js

@@ -9,4 +9,6 @@ module.exports.commit = require('./commit');
 module.exports.common = require('./common');
 module.exports.package = require('./package');
 module.exports.packageHistory = require('./package-history');
+module.exports.packageEnvs = require('./package-envs');
+module.exports.packageVersions = require('./package-versions');
 module.exports.stats = require('./stats');

package/scripts/csdr/metadata/package-envs.js

@@ -0,0 +1,71 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+const moment = require('moment');
+
+// LOCAL
+const tools = require('../../utils/tools');
+const configUtils = require('../config/config-utils');
+
+
+// FETCH ARGS
+const { dryRun } = tools.getArgs();
+
+
+module.exports.getMetadata = (pkg) => {
+  const DEVOPS_METADATA_PATH = configUtils.global.getConfigOptions().DEVOPS_METADATA_PATH;
+
+  return Promise.resolve()
+    .then(() => {
+      if (!DEVOPS_METADATA_PATH) {
+        throw new Error(`Devops metadata folder ${DEVOPS_METADATA_PATH} NOT FOUND`) ;
+      }
+
+      return tools.getJsonFileContent(path.join(DEVOPS_METADATA_PATH, pkg.devopsEnvsMetadataFile));
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+module.exports.storeMetadata = (pkg, newVersion, metadata, envTarget) => {
+  const releaseDate = moment(new Date()).format("DD/MM/YYYY HH:mm");
+  const infos = `${newVersion} - ${releaseDate}`;
+  const DEVOPS_METADATA_PATH = configUtils.global.getConfigOptions().DEVOPS_METADATA_PATH;
+
+  return Promise.resolve()
+    .then(() => {
+      tools.logTitle('Storing package environment metadata...');
+
+      const metadataFile = path.join(DEVOPS_METADATA_PATH, pkg.devopsEnvsMetadataFile);
+
+      var generatedMetadata;
+      if (tools.isFileExists(metadataFile)) {
+        generatedMetadata = require(metadataFile);
+      } else {
+        generatedMetadata = {};
+      }
+
+      generatedMetadata[envTarget] = {
+        version: newVersion,
+        releaseDate: releaseDate,
+        infos: infos,
+        dependencies: metadata
+      };
+
+      if (!dryRun) {
+        tools.writeJsonFileSync(metadataFile, generatedMetadata);
+      }
+    })
+
+    .then(() => {
+      tools.logSuccess();
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/metadata/package-history.js

@@ -3,7 +3,6 @@
 // GLOBAL
 const path = require('path');
 const execa = require('execa');
-const sanitizeHtml = require('sanitize-html');
 const moment = require('moment');
 const semver = require('semver');
 
@@ -127,6 +126,11 @@ const getDiffBetweenBuildVersions = (pkg, fromBuildMetadata, toBuildMetadata) =>
 
   const DEVOPS_METADATA_PATH = configUtils.global.getConfigOptions().DEVOPS_METADATA_PATH;
 
+  if (!fromBuildMetadata) {
+    tools.logWarning('No previous metadata found for package...skipping');
+    return null;
+  }
+
   return Promise.resolve()
     .then(() => {
       return innerCommon.getDevopsMetadata();

package/scripts/csdr/metadata/package-versions.js

@@ -0,0 +1,79 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+const moment = require('moment');
+
+// LOCAL
+const tools = require('../../utils/tools');
+const configUtils = require('../config/config-utils');
+
+
+// FETCH ARGS
+const { dryRun } = tools.getArgs();
+
+
+module.exports.getMetadata = (pkg) => {
+  const DEVOPS_METADATA_PATH = configUtils.global.getConfigOptions().DEVOPS_METADATA_PATH;
+
+  return Promise.resolve()
+    .then(() => {
+      if (!DEVOPS_METADATA_PATH) {
+        throw new Error(`Devops metadata folder ${DEVOPS_METADATA_PATH} NOT FOUND`) ;
+      }
+
+      return tools.getJsonFileContent(path.join(DEVOPS_METADATA_PATH, pkg.devopsVersionsMetadataFile));
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+module.exports.storeMetadata = (pkg, pkgVersion, pkgCompositeDeps, duration, envTarget) => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logInfo('Storing package version history metadata...');
+
+      const configOptions = configUtils.global.getConfigOptions();
+
+      var generatedMetadata = {};
+      var versions = [];
+
+      const pkgMetadataFile = path.join(configOptions.DEVOPS_METADATA_PATH, pkg.devopsVersionsMetadataFile);
+
+      if (tools.isFileExists(pkgMetadataFile)) {
+        generatedMetadata = require(pkgMetadataFile);
+        versions = generatedMetadata.versions;
+      }
+
+      const newVersionMetadata = {
+        name: pkg.name,
+        version: pkgVersion,
+        date: moment(new Date()).format("YYYYMMDD-HH:mm"),
+        npmPkg: pkg.npmPkg,
+        duration: duration,
+        envTarget: envTarget
+      };
+
+      if (pkg.remote) {
+        tools.logInfo('Writing remote composite dependencies');
+        newVersionMetadata.dependencies = pkgCompositeDeps;
+      }
+      console.log(newVersionMetadata);
+
+      versions.push(newVersionMetadata);
+
+      generatedMetadata.versions = versions;
+
+      tools.logInfo(`Write metadata on ${pkgMetadataFile}`);
+      if (!dryRun) {
+        tools.writeJsonFileSync(pkgMetadataFile, generatedMetadata);
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/metadata/package.js

@@ -11,6 +11,8 @@ const gitUtils = require('../../utils/git-utils');
 
 // INNER MODULES
 const innerCommon = require('./common');
+const innerPackageEnvs = require('./package-envs');
+const innerPackageVersions = require('./package-versions');
 
 // FETCH ARGS
 const { dryRun } = tools.getArgs();
@@ -57,8 +59,8 @@ module.exports.getPackagesDeps = (depsType) => {
 
 
 module.exports.storeMetadata = (
-    pkg, pkgVersion, pkgMetadata, isSnapshot, isMaster, isSupportBranch, isNextBranch, isSupportSnapshotBranch,
-    pkgCompositeDeps, duration,
+    pkg, pkgVersion, pkgMetadata, isSnapshot, isMaster, isSupportBranch, isNextBranch, isSupportSnapshotBranch, isHotfixBranch,
+    pkgCompositeDeps, duration, envTarget
   ) => {
 
   tools.logTitle('Storing central and package metadata...');
@@ -83,6 +85,7 @@ module.exports.storeMetadata = (
       var packagesPrevTag = [];
       var packagesNextTag = [];
       var packagesPrevSnapshotsTag = [];
+      var packagesHotfixTag = [0];
 
       if (tools.isFileExists(metadataFile)) {
         metadata = require(metadataFile);
@@ -91,6 +94,7 @@ module.exports.storeMetadata = (
         packagesPrevTag = metadata.packagesPrevTag;
         packagesNextTag = metadata.packagesNextTag;
         packagesPrevSnapshotsTag = metadata.packagesPrevSnapshotsTag;
+        packagesHotfixTag = metadata.packages.packagesHotfixTag;
       }
 
       const newPackage = {
@@ -209,11 +213,30 @@ module.exports.storeMetadata = (
         }
       }
 
+      if (isHotfixBranch) {
+        var pkgIdxHOTFIX;
+        if (packagesHotfixTag) {
+          pkgIdxHOTFIX = packagesHotfixTag.findIndex(item => item.name === pkg.name);
+        } else {
+          pkgIdxHOTFIX = -1;
+        }
+
+        if (pkgIdxHOTFIX > -1) {
+          packagesHotfixTag[pkgIdxHOTFIX] = newPackage;
+        } else {
+          if (!packagesHotfixTag) {
+            packagesHotfixTag = [];
+          }
+          packagesHotfixTag.push(newPackage);
+        }
+      }
+
       metadata.packages = packages;
       metadata.packagesLatestTag = packagesLatestTag;
       metadata.packagesPrevTag = packagesPrevTag;
       metadata.packagesNextTag = packagesNextTag;
       metadata.packagesPrevSnapshotsTag = packagesPrevSnapshotsTag;
+      metadata.packagesHotfixTag = packagesHotfixTag;
 
       if (!dryRun) {
         tools.writeJsonFileSync(metadataFile, metadata);
@@ -226,12 +249,18 @@ module.exports.storeMetadata = (
     })
 
     .then(() => {
-      return storeVersionsMetadata(pkg, pkgVersion, pkgCompositeDeps, duration);
+      return innerPackageVersions.storeMetadata(pkg, pkgVersion, pkgCompositeDeps, duration, envTarget);
+    })
+
+    .then(() => {
+      if (pkg.remote) {
+        return innerPackageEnvs.storeMetadata(pkg, pkgVersion, pkgCompositeDeps, envTarget);
+      }
     })
 
     .then(() => {
       if (isMaster) {
-        return storeBuildMetadata(pkg, pkgVersion, pkgMetadata);
+        return storeBuildMetadata(pkg, pkgVersion, pkgMetadata, envTarget);
       }
     })
 
@@ -264,54 +293,9 @@ module.exports.storeMetadata = (
 }
 
 
-const storeVersionsMetadata = module.exports.storeVersionsMetadata = (pkg, pkgVersion, pkgCompositeDeps, duration) => {
-  return Promise.resolve()
-    .then(() => {
-      tools.logInfo('Storing package version history metadata...');
-
-      const configOptions = configUtils.global.getConfigOptions();
-
-      var generatedMetadata = {};
-      var versions = [];
-
-      const pkgMetadataFile = path.join(configOptions.DEVOPS_METADATA_PATH, pkg.devopsVersionsMetadataFile);
-
-      if (tools.isFileExists(pkgMetadataFile)) {
-        generatedMetadata = require(pkgMetadataFile);
-        versions = generatedMetadata.versions;
-      }
-
-      const newVersionMetadata = {
-        name: pkg.name,
-        version: pkgVersion,
-        date: moment(new Date()).format("YYYYMMDD-HH:mm"),
-        npmPkg: pkg.npmPkg,
-        duration: duration
-      };
-
-      if (pkg.remote) {
-        tools.logInfo('Writing remote composite dependencies');
-        newVersionMetadata.dependencies = pkgCompositeDeps;
-      }
-      console.log(newVersionMetadata);
-
-      versions.push(newVersionMetadata);
-
-      generatedMetadata.versions = versions;
-
-      tools.logInfo(`Write metadata on ${pkgMetadataFile}`);
-      if (!dryRun) {
-        tools.writeJsonFileSync(pkgMetadataFile, generatedMetadata);
-      }
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
 
 
-const storeBuildMetadata = module.exports.storeBuildMetadata = (pkg, pkgVersion, pkgMetadata) => {
+const storeBuildMetadata = module.exports.storeBuildMetadata = (pkg, pkgVersion, pkgMetadata, envTarget) => {
   return Promise.resolve()
     .then(() => {
       tools.logInfo('Storing package LATEST metadata...');
@@ -328,7 +312,7 @@ const storeBuildMetadata = module.exports.storeBuildMetadata = (pkg, pkgVersion,
         versions = generatedMetadata.versions;
       }
 
-      versions.push({ name: pkgVersion, gitMetadata: pkgMetadata });
+      versions.push({ name: pkgVersion, envTarget: envTarget, gitMetadata: pkgMetadata });
       generatedMetadata.versions = versions;
 
       tools.logInfo(`Write metadata on ${pkgMetadataFile}`);
@@ -377,6 +361,31 @@ const storePipelineMetadata = module.exports.storePipelineMetadata = (pkgMetadat
 }
 
 
+module.exports.storeMetadataAssets = (pkg, pkgCompositeDeps) => {
+  return Promise.resolve()
+    .then(() => {
+      const pkgMetadataFile = path.join(pkg.paths.pkgBuild, 'bundles', 'package-metadata.json');
+      const pkgMetadataRootFile = path.join(pkg.paths.pkgDirectory, 'package-metadata.json');
+
+      const pkgMetadata = {
+        dependencies: pkgCompositeDeps
+      };
+
+      tools.logInfo(`Creating ${pkgMetadataFile}`);
+      console.log(pkgMetadata);
+
+      if (!dryRun) {
+        tools.writeJsonFileSync(pkgMetadataFile, pkgMetadata);
+        tools.writeJsonFileSync(pkgMetadataRootFile, pkgMetadata);
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
 module.exports.getPackageVersionsJson = (pkg) => {
   if (!pkg) {
     tools.logWarning('provided pkg is empty...skipping');
@@ -413,67 +422,30 @@ module.exports.getPackageVersionsLatest = (pkg) => {
 }
 
 
-module.exports.getPackageVersionsByMajor = (pkg, major) => {
+module.exports.getPackageVersionsByMajor = (pkg, major, isMaster) => {
   const pkgVersions = this.getPackageVersions(pkg);
 
   if (pkgVersions) {
     return pkgVersions.filter((v) => {
       return (v.version.split('.')[0] === major && v.version.indexOf('snapshot') === -1) ||
-             (v.version.split('.')[0] === major && pkg.build && pkg.build.isNextMajorSnapshotAllowed);
+             (v.version.split('.')[0] === major && pkg.build && pkg.build.isNextMajorSnapshotAllowed) ||
+             (v.version.split('.')[0] === major && pkg.build && pkg.build.supportSnapshotBranch) ||
+             (v.version.split('.')[0] === major && v.version.indexOf('snapshot') === -1 && isMaster);
     })
   }
 }
 
-module.exports.getLastMajorVersion = (pkg, major) => {
-  const pkgVersionsMajor = this.getPackageVersionsByMajor(pkg, major);
+module.exports.getLastMajorVersion = (pkg, major, isMaster) => {
+  const pkgVersionsMajor = this.getPackageVersionsByMajor(pkg, major, isMaster);
 
   if (pkgVersionsMajor && pkgVersionsMajor.length !== 0) {
     return pkgVersionsMajor.splice(-1)[0].version;
   }
 }
 
-module.exports.devopsMetadataToTable = (metadata) => {
-  tools.logTitle('Generating table from metadata...');
-
-  var content = '';
-
-  content += '<h3>Latest packages status</h3>';
-  content += '<table><thead><tr>';
-  content += '<th>PACKAGE</th>';
-  content += '<th>VERSION</th>';
-  content += '<th>DATE</th>';
-  content += '<th>STATUS</th>';
-  content += '</tr></thead>';
-  content += '<tbody>';
-  tools.sortArray(metadata.packages, 'name').forEach((item) => {
-    content += '<tr>';
-    content += `<td>${item.name}</td><td>${item.version}</td><td>${item.date}</td><td>${item.status}</td>`
-    content += '</tr>';
-  })
-  content += '</tbody>';
-  content += '</table>';
-
-  if (metadata.packagesLatestTag && metadata.packagesLatestTag.length !== 0) {
-    content += '<h3>Latest package tags</h3>';
-    content += '<table><thead><tr>';
-    content += '<th>PACKAGE</th>';
-    content += '<th>VERSION</th>';
-    content += '<th>DATE</th>';
-    // content+= '<th>STATUS</th>';
-    content += '</tr></thead>';
-    content += '<tbody>';
-    tools.sortArray(metadata.packagesLatestTag, 'name').forEach((item) => {
-      content += '<tr>';
-      content += `<td>${item.name}</td><td>${item.version}</td><td>${item.date}</td>`
-      content += '</tr>';
-    })
-    content += '</tbody>';
-    content += '</table>';
-  }
 
-  tools.logSuccess();
-  return content;
-}
+
+
 
 
 
@@ -484,7 +456,7 @@ module.exports.lockPackage = (pkg) => {
     .then(() => {
 
       const configOptions = configUtils.global.getConfigOptions();
-      const pkgLockFile = path.join(configOptions.DEVOPS_METADATA_PATH, `${pkg.name}-lock.json`);
+      const pkgLockFile = path.join(configOptions.DEVOPS_METADATA_LOCKS_PATH, `${pkg.name}-lock.json`);
 
       const lockContent = {
         locked: true,
@@ -498,7 +470,7 @@ module.exports.lockPackage = (pkg) => {
         return gitUtils.commitAndPush(
           'master',
           `chore: locking ${pkg.name}`,
-          configOptions.DEVOPS_METADATA_PATH
+          configOptions.DEVOPS_METADATA_LOCKS_PATH
         );
       }
     })
@@ -517,7 +489,7 @@ module.exports.unlockPackage = (pkg) => {
     .then(() => {
 
       const configOptions = configUtils.global.getConfigOptions();
-      const pkgLockFile = path.join(configOptions.DEVOPS_METADATA_PATH, `${pkg.name}-lock.json`);
+      const pkgLockFile = path.join(configOptions.DEVOPS_METADATA_LOCKS_PATH, `${pkg.name}-lock.json`);
 
       tools.remove(pkgLockFile);
 
@@ -526,7 +498,7 @@ module.exports.unlockPackage = (pkg) => {
         return gitUtils.commitAndPush(
           'master',
           `chore: unlocking ${pkg.name}`,
-          configOptions.DEVOPS_METADATA_PATH
+          configOptions.DEVOPS_METADATA_LOCKS_PATH
         );
       }
     })
@@ -539,7 +511,7 @@ module.exports.unlockPackage = (pkg) => {
 
 module.exports.isPackageLocked = (pkg) => {
   const configOptions = configUtils.global.getConfigOptions();
-  const pkgLockFile = path.join(configOptions.DEVOPS_METADATA_PATH, `${pkg.name}-lock.json`);
+  const pkgLockFile = path.join(configOptions.DEVOPS_METADATA_LOCKS_PATH, `${pkg.name}-lock.json`);
 
   if (dryRun) return false;
 
@@ -573,3 +545,99 @@ module.exports.isPackageLocked = (pkg) => {
 
   return false;
 }
+
+
+
+module.exports.syncDevopsMetadata = () => {
+  return Promise.resolve()
+    .then(() => {
+      const pkgsObject = configUtils.packages.getCsdrPackages();
+      const pkgs = Object.keys(pkgsObject);
+
+      const metadataFile = path.join(process.cwd(), 'packages', 'devops-metadata', '.devops-metadata.json');
+      const metadata = require(metadataFile);
+
+      let packages = metadata.packages;
+      let packagesLatestTag = metadata.packagesLatestTag;
+      let packagesNextTag = metadata.packagesNextTag;
+      let packagesPrevTag = metadata.packagesPrevTag;
+      let packagesPrevSnapshotsTag = metadata.packagesPrevSnapshotsTag;
+
+      const getMissingPackages = (inArray) => {
+        let outArray = [];
+
+        pkgs.forEach((p) => {
+          const pkgIdx = inArray.findIndex(item => item.name === p);
+          if (pkgIdx === -1) {
+            outArray.push(p);
+          }
+        });
+
+        return outArray;
+      }
+
+      const addPackages = (inArray, pkgsToAdd) => {
+        const outArray = inArray;
+        pkgsToAdd.forEach((p) => {
+          outArray.push({
+            name: p,
+            version: null,
+            date: require('moment')(new Date()).format("YYYYMMDD-HH:mm"),
+            status: 'INITIALIZED',
+            npmPkg: null
+          });
+        })
+
+        return outArray;
+      }
+
+      console.log('processing packages');
+      let packagesToAdd = [] = getMissingPackages(packages);
+      let packagesLatestTagToAdd = [] = getMissingPackages(packagesLatestTag);
+      let packagesNextTagToAdd = [] = getMissingPackages(packagesNextTag);
+      let packagesPrevTagToAdd = [] = getMissingPackages(packagesPrevTag);
+      let packagesPrevSnapshotsTagToAdd = [] = getMissingPackages(packagesPrevSnapshotsTag);
+
+      console.log(packagesToAdd.length);
+      console.log(packagesLatestTagToAdd.length);
+      console.log(packagesNextTagToAdd.length);
+      console.log(packagesPrevTagToAdd.length);
+      console.log(packagesPrevSnapshotsTagToAdd.length);
+
+      console.log(`packages before : ${packages.length}`);
+      packages = addPackages(packages, packagesToAdd);
+      console.log(`packages after : ${packages.length}`);
+
+      console.log(`packages before : ${packagesLatestTag.length}`);
+      packagesLatestTag = addPackages(packagesLatestTag, packagesLatestTagToAdd);
+      console.log(`packages after : ${packagesLatestTag.length}`);
+
+      console.log(`packages before : ${packagesNextTag.length}`);
+      packagesNextTag = addPackages(packagesNextTag, packagesNextTagToAdd);
+      console.log(`packages after : ${packagesNextTag.length}`);
+
+      console.log(`packages before : ${packagesPrevTag.length}`);
+      packagesPrevTag = addPackages(packagesPrevTag, packagesPrevTagToAdd);
+      console.log(`packages after : ${packagesPrevTag.length}`);
+
+      console.log(`packages before : ${packagesPrevSnapshotsTag.length}`);
+      packagesPrevSnapshotsTag = addPackages(packagesPrevSnapshotsTag, packagesPrevSnapshotsTagToAdd);
+      console.log(`packages after : ${packagesPrevSnapshotsTag.length}`);
+
+      metadata.packages = packages;
+      metadata.packagesLatestTag = packagesLatestTag;
+      metadata.packagesPrevTag = packagesPrevTag;
+      metadata.packagesNextTag = packagesNextTag;
+      metadata.packagesPrevSnapshotsTag = packagesPrevSnapshotsTag;
+
+      if (!dryRun) {
+        tools.writeJsonFileSync(metadataFile, metadata);
+      } else {
+        tools.logInfo(`Write metadata on ${metadataFile}`);
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}