@eui/tools 6.14.21 → 6.15.1

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

@@ -2,11 +2,107 @@
 
 // GLOBAL
 const path = require('path');
+const moment = require('moment');
 
 // LOCAL
 const tools = require('../../utils/tools');
 const configUtils = require('../config/config-utils');
 
+// ARGS
+const { dryRun } = tools.getArgs();
+
+
+module.exports.storeMetadata = (pkg, pkgVersion, pkgCompositeDeps, duration, envTarget) => {
+  tools.logTitle('Storing central and package metadata...');
+
+  return Promise.resolve()
+    .then(() => {
+      return storeMetadataVersions(pkg, pkgVersion, pkgCompositeDeps, duration, envTarget);
+    })
+
+    .then(() => {
+      return storeMetadataEnvs(pkg, pkgVersion, pkgCompositeDeps, envTarget);
+    })
+
+    .then(() => {
+      tools.logSuccess();
+    })
+
+    .catch((e) => {
+      throw e;
+    });
+};
+
+module.exports.getMetadataVersions = (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;
+    })
+}
+
+
+const storeMetadataVersions = (pkg, pkgVersion, pkgCompositeDeps, duration, envTarget) => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logInfo('Storing package version history metadata...');
+
+      const configOptions = configUtils.global.getConfigOptions();
+
+      let generatedMetadata = {};
+      let versions = [];
+
+      let pkgMetadataFile = path.join(configOptions.DEVOPS_METADATA_PATH, pkg.devopsVersionsMetadataFile);
+      if (pkg.backend) {
+        pkgMetadataFile = path.join(pkg.paths.root, 'package-versions-metadata.json');
+      }
+
+      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.logInfo('DRY RUN...outputing newVersionMetadata');
+
+      } else {
+        tools.writeJsonFileSync(pkgMetadataFile, generatedMetadata);
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
 
 const getPackageVersionsJson = (pkg) => {
   if (!pkg) {
@@ -17,7 +113,6 @@ const getPackageVersionsJson = (pkg) => {
   tools.logInfo(`Getting package versions for : ${pkg.name}...`);
 
   const configOptions = configUtils.global.getConfigOptions();
-
   const pkgMetadataFile = path.join(configOptions.DEVOPS_METADATA_PATH, pkg.devopsVersionsMetadataFile);
 
   tools.logInfo(`from ${pkgMetadataFile}`);
@@ -34,3 +129,95 @@ module.exports.getPackageVersionsLatest = (pkg) => {
     });
   }
 }
+
+
+module.exports.storeMetadataAssets = (pkg, pkgCompositeDeps) => {
+  return Promise.resolve()
+    .then(() => {
+      const pkgMetadataFile = path.join(pkg.paths.dist, 'bundles', 'package-metadata.json');
+      const pkgMetadataRootFile = path.join(pkg.paths.root, 'package-metadata.json');
+
+      const pkgMetadata = {
+        dependencies: pkgCompositeDeps,
+      };
+
+      if (dryRun) {
+        tools.logInfo('DRY RUN...outputing metadataAssets');
+        console.log(pkgMetadata);
+
+      } else {
+        tools.logInfo(`Creating ${pkgMetadataFile}`);
+        console.log(pkgMetadata);
+
+        tools.writeJsonFileSync(pkgMetadataFile, pkgMetadata);
+        tools.writeJsonFileSync(pkgMetadataRootFile, pkgMetadata);
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    });
+};
+
+
+module.exports.getMetadataEnvs = (pkg) => {
+  const DEVOPS_METADATA_PATH = configUtils.global.getConfigOptions().DEVOPS_METADATA_PATH;
+
+  return Promise.resolve()
+    .then(() => {
+      if (DEVOPS_METADATA_PATH) {
+        return tools.getJsonFileContent(path.join(DEVOPS_METADATA_PATH, pkg.devopsEnvsMetadataFile));
+      } else {
+        return;
+      }
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+const storeMetadataEnvs = (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.logInfo('Storing package environment metadata...');
+
+      const metadataFile = path.join(DEVOPS_METADATA_PATH, pkg.devopsEnvsMetadataFile);
+
+      let generatedMetadata;
+      if (tools.isFileExists(metadataFile)) {
+        generatedMetadata = require(metadataFile);
+      } else {
+        generatedMetadata = {};
+      }
+
+      generatedMetadata[envTarget] = {
+        version: newVersion,
+        releaseDate: releaseDate,
+        infos: infos,
+        dependencies: metadata
+      };
+
+      if (dryRun) {
+        tools.logInfo('DRY RUN...storing envs metadata');
+        console.log(generatedMetadata[envTarget]);
+
+      } else {
+        tools.logInfo(`Writing envs metadata to ${metadataFile}`);
+        tools.writeJsonFileSync(metadataFile, generatedMetadata);
+      }
+    })
+
+    .then(() => {
+      tools.logSuccess();
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/metadata/stats.js

@@ -455,83 +455,83 @@ module.exports.getCommitsByUsers = (packages, range = 'ALL') => {
 }
 
 
-module.exports.getRemoteAllStats = () => {
-
-  let stats = [];
-
-  return Promise.resolve()
-    .then(() => {
-      if (!dryRun && !skipClone && !tools.isDirExists(path.join(process.cwd(), 'packages', 'devops-metadata'))) {
-        return metadataUtils.common.cloneMetadataRepo();
-      }
-    })
-    .then(() => {
-      let remotesArray = [
-        ...configUtils.remotes.getCsdrRemotesArray('my-workplace', '17.x'),
-        ...configUtils.remotes.getCsdrRemotesArray('my-workplace', '16.x'),
-        ...configUtils.remotes.getCsdrRemotesArray('my-workplace', '15.x'),
-      ];
-
-      remotesArray = tools.sortArray(remotesArray, 'name');
-
-      remotesArray.forEach((r) => {
-        try {
-          const remote = configUtils.remotes.getRemote(r.name);
-          const versionsMatadata = metadataUtils.packageVersions.getMetadataSync(remote);
-          let versionsCount = 0, versionsCountEnvs = { "DEV": 0, "TST": 0, "INT": 0, "ACC": 0, "TRN": 0, "PROD": 0}, lastVersion = {};
-          if (versionsMatadata.versions) {
-            versionsCount = versionsMatadata.versions.length;
-            versionsCountEnvs['DEV'] = versionsMatadata.versions.filter(v => v.envTarget === 'DEV').length;
-            versionsCountEnvs['TST'] = versionsMatadata.versions.filter(v => v.envTarget === 'TST').length;
-            versionsCountEnvs['INT'] = versionsMatadata.versions.filter(v => v.envTarget === 'INT').length;
-            versionsCountEnvs['ACC'] = versionsMatadata.versions.filter(v => v.envTarget === 'ACC').length;
-            versionsCountEnvs['TRN'] = versionsMatadata.versions.filter(v => v.envTarget === 'TRN').length;
-            versionsCountEnvs['PROD'] = versionsMatadata.versions.filter(v => v.envTarget === 'PROD').length;
-            lastVersion = versionsMatadata.versions.slice(-1).pop();
-          }
-          const remoteStats = {
-            name: r.name,
-            // versions: versionsMatadata.versions,
-            lastVersion,
-            summary: {
-              versionsCount,
-              versionsCountEnvs
-            }
-          }
-          stats.push(remoteStats);
-        } catch(e) {}
-      })
-    })
-    .then(() => {
-      return {
-        stats
-      }
-    })
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-module.exports.getRemoteStats = (remoteName) => {
-  const remote = configUtils.remotes.getRemote(remoteName);
-
-  let versions;
-
-  return Promise.resolve()
-    .then(() => {
-      return metadataUtils.packageVersions.getMetadata(remote);
-    })
-    .then((metadata) => {
-      versions = metadata.versions;
-    })
-    .then(() => {
-      return {
-        versions
-      }
-    })
-    .catch((e) => {
-      throw e;
-    })
-}
+// module.exports.getRemoteAllStats = () => {
+
+//   let stats = [];
+
+//   return Promise.resolve()
+//     .then(() => {
+//       if (!dryRun && !skipClone && !tools.isDirExists(path.join(process.cwd(), 'packages', 'devops-metadata'))) {
+//         return metadataUtils.common.cloneMetadataRepo();
+//       }
+//     })
+//     .then(() => {
+//       let remotesArray = [
+//         ...configUtils.remotes.getCsdrRemotesArray('my-workplace', '17.x'),
+//         ...configUtils.remotes.getCsdrRemotesArray('my-workplace', '16.x'),
+//         ...configUtils.remotes.getCsdrRemotesArray('my-workplace', '15.x'),
+//       ];
+
+//       remotesArray = tools.sortArray(remotesArray, 'name');
+
+//       remotesArray.forEach((r) => {
+//         try {
+//           const remote = configUtils.remotes.getRemote(r.name);
+//           const versionsMatadata = metadataUtils.packageVersions.getMetadataSync(remote);
+//           let versionsCount = 0, versionsCountEnvs = { "DEV": 0, "TST": 0, "INT": 0, "ACC": 0, "TRN": 0, "PROD": 0}, lastVersion = {};
+//           if (versionsMatadata.versions) {
+//             versionsCount = versionsMatadata.versions.length;
+//             versionsCountEnvs['DEV'] = versionsMatadata.versions.filter(v => v.envTarget === 'DEV').length;
+//             versionsCountEnvs['TST'] = versionsMatadata.versions.filter(v => v.envTarget === 'TST').length;
+//             versionsCountEnvs['INT'] = versionsMatadata.versions.filter(v => v.envTarget === 'INT').length;
+//             versionsCountEnvs['ACC'] = versionsMatadata.versions.filter(v => v.envTarget === 'ACC').length;
+//             versionsCountEnvs['TRN'] = versionsMatadata.versions.filter(v => v.envTarget === 'TRN').length;
+//             versionsCountEnvs['PROD'] = versionsMatadata.versions.filter(v => v.envTarget === 'PROD').length;
+//             lastVersion = versionsMatadata.versions.slice(-1).pop();
+//           }
+//           const remoteStats = {
+//             name: r.name,
+//             // versions: versionsMatadata.versions,
+//             lastVersion,
+//             summary: {
+//               versionsCount,
+//               versionsCountEnvs
+//             }
+//           }
+//           stats.push(remoteStats);
+//         } catch(e) {}
+//       })
+//     })
+//     .then(() => {
+//       return {
+//         stats
+//       }
+//     })
+//     .catch((e) => {
+//       throw e;
+//     })
+// }
+
+
+// module.exports.getRemoteStats = (remoteName) => {
+//   const remote = configUtils.remotes.getRemote(remoteName);
+
+//   let versions;
+
+//   return Promise.resolve()
+//     .then(() => {
+//       return metadataUtils.packageVersions.getMetadata(remote);
+//     })
+//     .then((metadata) => {
+//       versions = metadata.versions;
+//     })
+//     .then(() => {
+//       return {
+//         versions
+//       }
+//     })
+//     .catch((e) => {
+//       throw e;
+//     })
+// }
 

package/scripts/csdr/release/app/release-app.js

@@ -17,7 +17,7 @@ module.exports.run = () => {
   const project = configUtils.projects.getProject();
 
   // fetching command parameters
-  var { branch, dryRun, envTarget, compositeType, configEnvTarget } = utils.tools.getArgs();
+  let { branch, envTarget, configEnvTarget } = utils.tools.getArgs();
 
   // checking branch and envTarget types
   if (branch && typeof branch === 'boolean') {
@@ -37,9 +37,9 @@ module.exports.run = () => {
   }
 
   // Getting branch flags
-  var isSupportSnapshotBranch;
-  var isSupportBranch;
-  var isSnapshot;
+  let isSupportSnapshotBranch;
+  let isSupportBranch;
+  let isSnapshot;
 
   if (branch) {
     isSupportSnapshotBranch = branch !== 'master' && branch.indexOf('support/develop') > -1;
@@ -51,7 +51,7 @@ module.exports.run = () => {
   // Classical app repo develop/master branches can still be used
   // the envTarget generated is deducted in that case
 
-  var envTargetGen;
+  let envTargetGen;
   // when envTarget is provided in process v2 for MWP, this take the lead
   if (envTarget) {
     envTargetGen = envTarget;
@@ -65,17 +65,8 @@ module.exports.run = () => {
     }
   }
 
-  // Initialize composite type
-  if (compositeType && typeof compositeType === 'boolean') {
-    compositeType = null;
-  }
-
-  if (!compositeType) {
-    compositeType = 'DEFAULT';
-  }
-
   // Modules global declarations
-  var newVersion, packagesDeps;
+  let newVersion, packagesDeps;
 
   // Starting the release process
   return (
@@ -100,7 +91,7 @@ module.exports.run = () => {
 
         return utils.notification.project.sendProjectMessage({
           project: project,
-          text: `:arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: Launching *${project.name}* release for *${envTargetGen}* environment - composite type: *${compositeType}`,
+          text: `:arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: Launching *${project.name}* release for *${envTargetGen}* environment`,
         });
       })
 
@@ -125,7 +116,7 @@ module.exports.run = () => {
       .then(() => {
         // installing the dependencies by composite definition, it's outputting the app package dependencies declared
         // in the dependencies-composite.json file of the project, remapped with the composite declaration per env.
-        return installUtils.buildApp.install(project, envTargetGen, compositeType);
+        return installUtils.buildApp.install(project, envTargetGen);
       })
       // saving current generated deps metadata for build version
       .then((deps) => {

package/scripts/csdr/release/package/common.js

@@ -17,7 +17,11 @@ const { dryRun, pipelineId } = utils.tools.getArgs();
 
 
 const getBranches = module.exports.getBranches = () => {
-  const { branch } = utils.tools.getArgs();
+  let { branch } = utils.tools.getArgs();
+
+  if (!branch) {
+    branch = 'master';
+  }
 
   const isSnapshot =  (branch === 'develop');
   const isMaster =  (branch === 'master');
@@ -45,7 +49,7 @@ const getBranches = module.exports.getBranches = () => {
 }
 
 module.exports.getEnvTarget = () => {
-  var { envTarget } = utils.tools.getArgs();
+  let { envTarget } = utils.tools.getArgs();
 
   // Initialize composite type
   if (envTarget && typeof (envTarget) === 'boolean') {
@@ -71,23 +75,8 @@ module.exports.getEnvTarget = () => {
   return envTargetGen;
 }
 
-module.exports.getCompositeType = () => {
-  let { compositeType } = utils.tools.getArgs();
-
-  // Initialize composite type
-  if (compositeType && typeof (compositeType) === 'boolean') {
-    compositeType = null;
-  }
-
-  if (!compositeType) {
-    compositeType = 'DEFAULT';
-  }
-
-  return compositeType;
-}
-
 
-module.exports.init = (pkg, envTarget, compositeType) => {
+module.exports.init = (pkg, envTarget) => {
   utils.tools.logBanner('INIT');
 
   const branches = this.getBranches();
@@ -95,12 +84,12 @@ module.exports.init = (pkg, envTarget, compositeType) => {
   // checking if at least the branch has been given as a parameter
   if (!branches.branch) {
     utils.tools.logError('ERROR : "branch" NOT PROVIDED as argument !!!');
-    throw 'BRANCH_NOT_PROVIDED';
+    throw new Error('BRANCH_NOT_PROVIDED');
 
   // for envTarget / à la carte remote delivery, only master branch is allowed
   } else {
     if (pkg.remote && pkg.build && pkg.build.envTargetActive && !branches.isMaster) {
-      throw 'REMOTE_ENVTARGET_NOT_MASTER_BRANCH';
+      throw new Error('REMOTE_ENVTARGET_NOT_MASTER_BRANCH');
     }
   }
 
@@ -124,7 +113,7 @@ module.exports.init = (pkg, envTarget, compositeType) => {
       let launchMessage = ':arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward:';
 
       if (pkg.remote) {
-        launchMessage += ` Launching remote *${pkg.name}* release for ENV: *${envTarget}* - compositeType: *${compositeType}*`;
+        launchMessage += ` Launching remote *${pkg.name}* release for ENV: *${envTarget}*`;
       } else {
         launchMessage += ` Launching *${pkg.name}* release for branch *${branches.branch}*`;
       }
@@ -198,7 +187,7 @@ module.exports.preReleaseChecks = (pkg) => {
 
     if (!branches.valid) {
       utils.tools.logInfo('Branch not supported ... stopping : allowed branches are develop-master-next/-support/-hotfix/');
-      throw 'BRANCH_NOT_SUPPORTED';
+      throw new Error('BRANCH_NOT_SUPPORTED');
 
     } else {
       utils.tools.logInfo('Branch is valid... processing');
@@ -216,13 +205,13 @@ module.exports.preReleaseChecks = (pkg) => {
 
       } else {
         // if package is locked, exception is thrown, check this specific exception handling in the global catch
-        if (metadataUtils.package.isPackageLocked(pkg)) {
+        if (metadataUtils.packageUtils.isPackageLocked(pkg)) {
           utils.tools.logInfo('Package is locked ==> throwing exception');
           throw 'PACKAGE_LOCKED';
 
           // if package is not locked, we lock it
         } else {
-          return metadataUtils.package.lockPackage(pkg);
+          return metadataUtils.packageUtils.lockPackage(pkg);
         }
       }
     }
@@ -408,9 +397,7 @@ module.exports.storeMetadataAssets = (pkg, pkgCompositeDeps) => {
 
   return Promise.resolve()
     .then(() => {
-      if (pkg.remote) {
-        return metadataUtils.package.storeMetadataAssets(pkg, pkgCompositeDeps);
-      }
+      return metadataUtils.remotePackage.storeMetadataAssets(pkg, pkgCompositeDeps);
     })
 
     .catch((e) => {
@@ -506,90 +493,6 @@ module.exports.runGitOperations = (pkg, version) => {
 
 
 
-module.exports.storeMetadata = (pkg, version, pkgMetadata, pkgCompositeDeps, duration, envTarget) => {
-  utils.tools.logBanner('STORE METADATA');
-
-  const branches = this.getBranches();
-
-  return Promise.resolve()
-  .then(() => {
-    return metadataUtils.package.storeMetadata(
-      pkg, version, pkgMetadata,
-      branches,
-      pkgCompositeDeps,
-      duration,
-      envTarget,
-    );
-  })
-
-  .catch((e) => {
-    throw e;
-  })
-}
-
-
-
-module.exports.storeMetadataBackend = (pkg, version, pkgMetadata, duration, envTarget) => {
-  utils.tools.logBanner('STORE BACKEND METADATA');
-
-  const branches = this.getBranches();
-
-  return Promise.resolve()
-  .then(() => {
-    return metadataUtils.package.storeMetadataBackend(
-      pkg, version, pkgMetadata,
-      branches.isMaster,
-      duration,
-      envTarget
-    );
-  })
-
-  .catch((e) => {
-    throw e;
-  })
-}
-
-
-module.exports.generateDiffReport = (pkg, newVersion) => {
-  utils.tools.logBanner('GENERATE DIFF REPORT');
-
-  var { envTarget } = utils.tools.getArgs();
-
-  // Initialize composite type
-  if (envTarget && typeof (envTarget) === 'boolean') {
-    envTarget = null;
-  }
-
-  return Promise.resolve()
-  .then(() => {
-    return metadataUtils.packageHistory.generateDiffReport(pkg, envTarget);
-  })
-
-  .then((diffMetadata) => {
-    if (diffMetadata) {
-      return Promise.resolve()
-        .then(() => {
-          return metadataUtils.packageHistory.flattenDiffMetadata(diffMetadata);
-        })
-
-        .then((flatDiffMetadata) => {
-          return utils.notification.package.sendPackageDiffReportMessage(
-            pkg,
-            flatDiffMetadata
-          );
-        })
-
-        .then(() => {
-          return metadataUtils.packageHistory.storeMetadata(pkg, diffMetadata, newVersion);
-        })
-    }
-  })
-
-  .catch((e) => {
-    throw e;
-  })
-}
-
 module.exports.commitMetadata = (pkg, version) => {
 
   const configOptions = configUtils.global.getConfigOptions();
@@ -612,7 +515,7 @@ module.exports.commitMetadata = (pkg, version) => {
 
 
 
-module.exports.exportPipelineVariables = (pkg, compositeType) => {
+module.exports.exportPipelineVariables = (pkg) => {
   utils.tools.logBanner('EXPORT PIPELINE VARIABLES');
 
   let variablesContent = '';
@@ -630,13 +533,10 @@ module.exports.exportPipelineVariables = (pkg, compositeType) => {
     }
 
     utils.tools.logInfo(`appTarget generated : ${appTarget}`);
-
     variablesContent += `export APP_TARGET=${appTarget}\n`;
 
-    if (compositeType) {
-      utils.tools.logInfo(`Exporting COMPOSITE_TYPE : ${compositeType}`);
-      variablesContent += `export COMPOSITE_TYPE=${compositeType}\n`;
-    }
+    utils.tools.logInfo(`Exporting COMPOSITE_TYPE : DEFAULT`);
+    variablesContent += `export COMPOSITE_TYPE=DEFAULT\n`;
 
     if (dryRun) {
       utils.tools.logWarning('dryRun...skipping export');
@@ -691,7 +591,7 @@ module.exports.sendSuccessNotification = (pkg, version, pkgMetadata) => {
           if (pkg.build && pkg.build.skipLock) {
             utils.tools.logInfo('lock package de-activated...skipping');
           } else {
-            return metadataUtils.package.unlockPackage(pkg);
+            return metadataUtils.packageUtils.unlockPackage(pkg);
           }
         })
         .catch((e) => {
@@ -734,7 +634,7 @@ module.exports.sendErrorNotification = (pkg, exception, pkgMetadata) => {
             if (pkg.build && pkg.build.skipLock) {
               utils.tools.logInfo('lock package de-activated...skipping');
             } else {
-              return metadataUtils.package.unlockPackage(pkg);
+              return metadataUtils.packageUtils.unlockPackage(pkg);
             }
           })
           .catch((e) => {