@eui/tools 5.0.0-rc.9 → 5.1.2

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();
@@ -17,7 +16,7 @@ const innerAppHistory = require('./app-history');
 const innerAppEnvs = require('./app-envs');
 
 
-module.exports.cloneMetadataRepo = () => {
+module.exports.cloneMetadataRepo = (noHistory = false) => {
   const configOptions = configUtils.global.getConfigOptions();
 
   tools.logTitle('Cloning devops metadata repo');
@@ -29,7 +28,28 @@ module.exports.cloneMetadataRepo = () => {
   } else {
     return Promise.resolve()
       .then(() => {
-        return gitUtils.cloneRepo(configOptions.DEVOPS_METADATA_REPOSITORY, configOptions.DEVOPS_METADATA_PATH, false, true);
+        return gitUtils.cloneRepo(configOptions.DEVOPS_METADATA_REPOSITORY, configOptions.DEVOPS_METADATA_PATH, false, noHistory);
+      })
+      .catch((e) => {
+        throw e;
+      })
+  }
+}
+
+
+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;
@@ -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

@@ -126,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);
       }
     })
 
@@ -241,6 +270,12 @@ module.exports.storeMetadata = (
       }
     })
 
+    .then(() => {
+      if (isMaster && pkg.remote) {
+        return innerCommon.generateDiffReport(pkg, pkgVersion);
+      }
+    })
+
     .then(() => {
       tools.logTitle('Commiting metadata info');
       return gitUtils.commitAndPush(
@@ -264,54 +299,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 = (pkg, pkgVersion, pkgMetadata, envTarget) => {
   return Promise.resolve()
     .then(() => {
       tools.logInfo('Storing package LATEST metadata...');
@@ -328,7 +318,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}`);
@@ -343,7 +333,7 @@ const storeBuildMetadata = module.exports.storeBuildMetadata = (pkg, pkgVersion,
 }
 
 
-const storePipelineMetadata = module.exports.storePipelineMetadata = (pkgMetadata) => {
+const storePipelineMetadata = (pkgMetadata) => {
   return Promise.resolve()
     .then(() => {
       tools.logInfo('Storing package pipeline metadata into root variables...');
@@ -377,6 +367,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 +428,40 @@ 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);
-    })
+    tools.logInfo(`----> ${pkgVersions.length} metadata versions found for package`);
+    let versions = [];
+    versions = pkgVersions.filter(v => v.version.split('.')[0] === major);
+
+    tools.logInfo(`----> ${versions.length} metadata versions found for major version : ${major}`);
+
+    if (isMaster) {
+      versions = versions.filter(v => v.version.indexOf('snapshot') === -1);
+      tools.logInfo(`----> ${versions.length} metadata versions found excluding snapshots`);
+
+    } else {
+      versions = versions.filter(v => v.version.indexOf('snapshot') !== -1);
+      tools.logInfo(`----> ${versions.length} metadata versions found including snapshots`);
+    }
+
+    return versions;
   }
 }
 
-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 +472,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 +486,7 @@ module.exports.lockPackage = (pkg) => {
         return gitUtils.commitAndPush(
           'master',
           `chore: locking ${pkg.name}`,
-          configOptions.DEVOPS_METADATA_PATH
+          configOptions.DEVOPS_METADATA_LOCKS_PATH
         );
       }
     })
@@ -517,7 +505,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 +514,7 @@ module.exports.unlockPackage = (pkg) => {
         return gitUtils.commitAndPush(
           'master',
           `chore: unlocking ${pkg.name}`,
-          configOptions.DEVOPS_METADATA_PATH
+          configOptions.DEVOPS_METADATA_LOCKS_PATH
         );
       }
     })
@@ -539,7 +527,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 +561,5 @@ module.exports.isPackageLocked = (pkg) => {
 
   return false;
 }
+
+

package/scripts/csdr/metadata/stats.js

@@ -10,7 +10,7 @@ const configUtils = require('../config/config-utils');
 const metadataUtils = require('../metadata/metadata-utils');
 
 // FETCH ARGS
-const { dryRun } = tools.getArgs();
+const { dryRun, skipClone } = tools.getArgs();
 
 
 const groupBy = (xs, f) => {
@@ -29,7 +29,7 @@ module.exports.run = () => {
 
   return Promise.resolve()
     .then(() => {
-      if (!dryRun) {
+      if (!dryRun && !skipClone) {
         return metadataUtils.common.cloneMetadataRepo();
       }
     })
@@ -45,6 +45,8 @@ module.exports.run = () => {
 
       // Accumulating all packages metadata in one single object
       packages.forEach((p) => {
+        console.log(`Processing package : ${p.name}`);
+
         const metadataRoot = path.join(process.cwd(), 'packages', 'devops-metadata');
         const pkgMetadata = tools.getJsonFileContent(path.join(metadataRoot, p.devopsMetadataFile));
         const pkgMetadataVersions = tools.getJsonFileContent(path.join(metadataRoot, p.devopsVersionsMetadataFile));
@@ -52,9 +54,11 @@ module.exports.run = () => {
         const gitCommits = [];
         if (pkgMetadata.versions) {
           pkgMetadata.versions.forEach((v) => {
-            v.gitMetadata.commits.forEach((c) => {
-              gitCommits.push(c);
-            });
+            if (v.gitMetadata.commits) {
+              v.gitMetadata.commits.forEach((c) => {
+                gitCommits.push(c);
+              });
+            }
           });
         }
 

package/scripts/csdr/metadata/v2/app/_app.js

@@ -0,0 +1,21 @@
+'use strict';
+
+// LOCALS
+const utils = require('../../../../utils');
+
+
+// PUBLIC METHODS
+module.exports.getMetadata = (app) => {
+  return Promise.resolve()
+    .then(() => {
+      const urlPath = `/app/${app.name}`;
+      return utils.api.get(urlPath);
+    })
+    .then((data) => {
+      return data;
+    })
+    .catch((e) => {
+      utils.tools.logDebugTrace(__filename, 'getMetadata', e);
+      throw e;
+    })
+}

package/scripts/csdr/metadata/v2/app/app.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// LOCALS
+const utils = require('../../../../utils');
+
+// PRIVATES
+const _app = require('./_app');
+
+
+// PUBLIC METHODS
+module.exports.getMetadata = (app) => {
+  utils.tools.logTitle('Get app metadata');
+
+  return Promise.resolve()
+    .then(() => {
+      return _app.getMetadata(app);
+    })
+    .then((metadata) => {
+      return metadata;
+    })
+    .catch((e) => {
+      utils.tools.logErrorTrace(__filename, 'getMetadata', e);
+      throw e;
+    })
+}