@eui/tools 6.14.20 → 6.15.0

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-group.js

@@ -46,15 +46,6 @@ module.exports.run = () => {
     isMaster = branch === 'master';
   }
 
-  // deducting envTarget from branch
-  let envTargetGen;
-
-  if (isSnapshot || isSupportSnapshotBranch) {
-    envTargetGen = 'DEV';
-  } else {
-    envTargetGen = 'PROD';
-  }
-
   // Starting the release process
   return (
     Promise.resolve()

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;
@@ -61,21 +61,12 @@ module.exports.run = () => {
     if (isSnapshot || isSupportSnapshotBranch) {
       envTargetGen = 'DEV';
     } else {
-      envTargetGen = 'PROD';
+      envTargetGen = 'TST';
     }
   }
 
-  // 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) => {