@eui/tools 5.0.0-rc.9 → 5.1.0

package/scripts/csdr/version/app-common.js

@@ -0,0 +1,32 @@
+'use strict';
+
+// externals
+const path = require('path');
+
+// local
+const tools = require('../../utils/tools');
+
+
+// fetch args
+const { dryRun } = tools.getArgs();
+
+
+module.exports.updatePackageVersion = (project, newVersion) => {
+  return Promise.resolve()
+    .then(() => {
+      const pkgJsonFile = path.join(process.cwd(), project.folder, 'package.json');
+      const pkgJson = require(pkgJsonFile);
+
+      tools.logTitle('Updating package version');
+      pkgJson.version = newVersion;
+
+      if (!dryRun) {
+        tools.writeJsonFileSync(pkgJsonFile, pkgJson);
+      }
+
+      tools.logSuccess(newVersion);
+    })
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/version/app-env-target.js

@@ -1,146 +1,14 @@
 'use strict';
 
-// externals
-const semver = require('semver');
-
 // local
 const tools = require('../../utils/tools');
 const metadataUtils = require('../metadata/metadata-utils');
 
-// fetch args
-const { dryRun } = tools.getArgs();
-
-
-const getNewVersionForDev = (versionsMetadata, envsMetadata, rootEnv) => {
-  let version;
-  const lastIntMetadata = envsMetadata[rootEnv];
-
-  if (lastIntMetadata) {
-    const rootVersion = semver.coerce(envsMetadata[rootEnv].version).raw;
-    version = semver.inc(rootVersion, 'major') + '-SNAPSHOT';
-  } else {
-    version = '1.0.0-SNAPSHOT';
-  }
-
-  tools.logInfo(`Probable new version : ${version}`);
-
-  // if no versions history is found for the current project, initial version is set
-  if (!versionsMetadata.versions) {
-    tools.logSuccess(`No historical version found : version = ${version}`);
-    version += '.0';
-
-  } else {
-    // check if the root version already exsists
-    const prevVersions = versionsMetadata.versions.filter((v) => {
-      return v.name.indexOf(version) > -1;
-    });
-
-    // do the increment over the last version found having the same root version
-    if (prevVersions.length) {
-      const lastVersion = prevVersions[prevVersions.length - 1];
-
-      if (lastVersion) {
-        tools.logInfo(`Version already found [${lastVersion.name}]`);
-        version = semver.inc(lastVersion.name, 'prerelease');
-        tools.logSuccess(`Final version : ${version}`);
-      }
-
-      // if it's a branch new DEV stream release, the snapshot is itialized
-    } else {
-      version += '.0';
-    }
-  }
-
-  return version;
-}
-
-
-const getNewVersionForEnv = (versionsMetadata, envsMetadata, rootEnv, envTarget) => {
-  let version;
-
-  tools.logInfo(`Fetching version from rootEnv: ${rootEnv} for target: ${envTarget}`);
-
-  // check if envMetadata contains data for the rootEnv
-  if (!envsMetadata[rootEnv]) {
-    throw new Error(`No metadata found for rootEnv: ${rootEnv} for envTarget build: ${envTarget}`);
-  }
-
-  // get the last DEV version from env metadata
-  const lastRootEnvVersion = envsMetadata[rootEnv].version;
-
-  tools.logInfo(`Fetched last version from ${rootEnv} : ${lastRootEnvVersion}`);
-
-  // coerce the version (X.Y.Z-SNAPSHOT will generate : X.Y.Z)
-  const rootVersion = semver.coerce(lastRootEnvVersion).raw;
-
-  // check if the root version already exists
-  const prevVersions = versionsMetadata.versions.filter((v) => {
-    return v.name.indexOf(rootVersion) > -1 && v.envTarget === envTarget;
-  });
-
-  if (prevVersions.length) {
-    const lastVersion = prevVersions[prevVersions.length - 1];
-
-    tools.logInfo(`Version already found [${lastVersion.name}]`);
-    version = semver.inc(lastVersion.name, 'prerelease');
-    tools.logInfo(`Incremented version : ${version}`);
-
-  } else {
-    version = rootVersion + '-' + envTarget + '.0';
-  }
-
-  tools.logSuccess(`Final version : ${version}`);
-
-  return version;
-}
-
-
-const getNewVersionForProd = (versionsMetadata, envsMetadata) => {
-  let version;
-
-  // get the last DEV version from env metadata
-  const lastAccVersion = envsMetadata['ACC'].version;
-
-  tools.logInfo(`Fetched last version from ACC : ${lastAccVersion}`);
+// inner modules
+const innerCommon = require('./common');
 
-  // coerce the version (X.Y.Z-INT.n will generate : X.Y.Z)
-  const rootVersion = semver.coerce(lastAccVersion).raw;
-  const tempVersion = rootVersion.split('.');
-  const rootVersionMinor = `${tempVersion[0]}.${tempVersion[1]}`;
 
-  // check if the root version already exists
-  const prevVersions = versionsMetadata.versions.filter((v) => {
-    return v.name.indexOf(rootVersionMinor) > -1 && v.envTarget === 'PROD';
-  });
-
-  if (prevVersions.length) {
-    const lastVersion = prevVersions[prevVersions.length - 1];
-
-    tools.logInfo(`Version already found [${lastVersion.name}]`);
-    version = semver.inc(lastVersion.name, 'patch');
-    tools.logInfo(`Incremented version : ${version}`);
-
-  } else {
-    version = rootVersion;
-  }
-
-  tools.logSuccess(`Final version : ${version}`);
-
-  return version;
-}
-
-
-
-
-
-
-
-
-
-// PUBLIC METHODS
-
-// for env-based build, we take the latest TST release version as the base
-const getNewVersion = (project, envTarget) => {
+module.exports.getNewVersion = (project, envTarget) => {
   let versionsMetadata;
   let envsMetadata;
 
@@ -166,10 +34,10 @@ const getNewVersion = (project, envTarget) => {
     .then(() => {
       switch(project.options.BUILD_VERSION_STRATEGY_ENVS_CYCLE) {
         case 'DEV_TST_ACC_PROD':
-          return getNewVersionDTAP(envTarget, versionsMetadata, envsMetadata);
+          return innerCommon.getNewVersionDTAP(envTarget, versionsMetadata, envsMetadata);
 
         default:
-          return getNewVersionDefault(envTarget, versionsMetadata, envsMetadata);
+          return innerCommon.getNewVersionDefault(envTarget, versionsMetadata, envsMetadata);
       }
     })
 
@@ -179,161 +47,3 @@ const getNewVersion = (project, envTarget) => {
 }
 
 
-
-
-const getNewVersionDefault = (envTarget, versionsMetadata, envsMetadata) => {
-  tools.logInfo(`Retrieve version for ${envTarget}`);
-
-  return Promise.resolve()
-    .then(() => {
-      let version;
-
-      // =====================================================================
-      // DEV target : format : X.Y.Z-SNAPSHOT.n
-      //  - where X.Y.Z is last INT release next MAJOR version
-      // =====================================================================
-
-      if (envTarget === 'DEV') {
-        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'INT');
-      }
-
-
-      // =====================================================================
-      // TST target : format : X.Y.Z-TST.n
-      //   - where X.Y.Z is the last root version of DEV env target
-      // =====================================================================
-
-      if (envTarget === 'TST') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'DEV', 'TST');
-      }
-
-
-      // =====================================================================
-      // INT target : format : X.Y.Z-INT.n
-      //   - where X.Y.Z is the last root version of TST env target
-      // =====================================================================
-
-      if (envTarget === 'INT') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'TST', 'INT');
-      }
-
-
-      // =====================================================================
-      // ACC target : format : X.Y.Z-envTarget.n
-      //   - where X.Y.Z is the last root version of INT env target
-      // =====================================================================
-
-      if (envTarget === 'ACC') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'INT', 'ACC');
-      }
-
-      // =====================================================================
-      // DLT targets : format : X.Y.Z-envTarget.n
-      //   - where X.Y.Z is the last root version of ACC env target
-      // =====================================================================
-
-      if (envTarget === 'DLT') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'ACC', 'DLT');
-      }
-
-      // =====================================================================
-      // TRN targets : format : X.Y.Z-envTarget.n
-      //   - where X.Y.Z is the last root version of PROD env target
-      // =====================================================================
-
-      if (envTarget === 'TRN') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'ACC', 'TRN');
-      }
-
-      // =====================================================================
-      // FOR PROD : format X.Y.Z(+1)
-      //   - where X.Y.Z is the last version of PROD with the same INT root
-      // =====================================================================
-
-      if (envTarget === 'PROD') {
-        version = getNewVersionForProd(versionsMetadata, envsMetadata);
-      }
-
-      // Check if version has been found, it can never be empty
-      if (!version) {
-        throw new Error(`Unable to generate version for ${envTarget}`);
-      }
-
-      return version;
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-
-
-const getNewVersionDTAP = (envTarget, versionsMetadata, envsMetadata) => {
-  tools.logInfo(`Retrieve version for ${envTarget}`);
-
-  return Promise.resolve()
-    .then(() => {
-      let version;
-
-      // =====================================================================
-      // DEV target : format : X.Y.Z-SNAPSHOT.n
-      //  - where X.Y.Z is last INT release next MAJOR version
-      // =====================================================================
-
-      if (envTarget === 'DEV') {
-        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'TST');
-      }
-
-
-      // =====================================================================
-      // TST target : format : X.Y.Z-TST.n
-      //   - where X.Y.Z is the last root version of DEV env target
-      // =====================================================================
-
-      if (envTarget === 'TST') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'DEV', 'TST');
-      }
-
-
-      // =====================================================================
-      // ACC target : format : X.Y.Z-envTarget.n
-      //   - where X.Y.Z is the last root version of INT env target
-      // =====================================================================
-
-      if (envTarget === 'ACC') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'TST', 'ACC');
-      }
-
-
-      // =====================================================================
-      // FOR PROD : format X.Y.Z(+1)
-      //   - where X.Y.Z is the last version of PROD with the same INT root
-      // =====================================================================
-
-      if (envTarget === 'PROD') {
-        version = getNewVersionForProd(versionsMetadata, envsMetadata);
-      }
-
-      // Check if version has been found, it can never be empty
-      if (!version) {
-        throw new Error(`Unable to generate version for ${envTarget}`);
-      }
-
-      return version;
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-
-
-module.exports = {
-  getNewVersion,
-  getNewVersionDefault,
-  getNewVersionDTAP,
-}

package/scripts/csdr/version/app.js

@@ -2,9 +2,7 @@
 
 const appDefault = require('./app-default');
 const appEnvTarget = require('./app-env-target');
-
-module.exports.updatePackageVersion = appDefault.updatePackageVersion;
-module.exports.getCurrentVersion = appDefault.getCurrentVersion;
+const appCommon = require('./app-common');
 
 
 module.exports.getNewVersion = (project, isSnapshot, isSupportBranch, envTarget) => {
@@ -21,3 +19,7 @@ module.exports.getNewVersion = (project, isSnapshot, isSupportBranch, envTarget)
       throw e;
     })
 }
+
+module.exports.updatePackageVersion = appCommon.updatePackageVersion;
+
+module.exports.getCurrentVersion = appCommon.getCurrentVersion;

package/scripts/csdr/version/common.js

@@ -0,0 +1,282 @@
+'use strict';
+
+// externals
+const semver = require('semver');
+
+// local
+const tools = require('../../utils/tools');
+
+
+const getNewVersionForDev = (versionsMetadata, envsMetadata, rootEnv) => {
+  let version;
+  const lastIntMetadata = envsMetadata[rootEnv];
+
+  if (lastIntMetadata) {
+    tools.logInfo('Last INT metadata found')
+    const rootVersion = semver.coerce(envsMetadata[rootEnv].version).raw;
+    version = semver.inc(rootVersion, 'major') + '-SNAPSHOT';
+    tools.logInfo(`base version : ${version}`);
+
+  } else {
+    tools.logInfo('No INT metadata found : initializing version');
+    version = '1.0.0-SNAPSHOT';
+    tools.logInfo(`version intialized : ${version}`);
+  }
+
+  // if no versions history is found for the current project, initial version is set
+  if (!versionsMetadata.versions) {
+    tools.logSuccess(`No historical version found : version = ${version}`);
+    version += '.0';
+
+  } else {
+    // check if the root version already exsists
+    const prevVersions = versionsMetadata.versions.filter((v) => {
+      return v.version.indexOf(version) > -1;
+    });
+
+    tools.logInfo(`prevVersions found : ${JSON.stringify(prevVersions, null, 2)}`);
+
+    // do the increment over the last version found having the same root version
+    if (prevVersions.length) {
+      const lastVersion = prevVersions[prevVersions.length - 1];
+
+      if (lastVersion) {
+        tools.logInfo(`Version already found [${lastVersion.version}]`);
+        version = semver.inc(lastVersion.version, 'prerelease');
+        tools.logSuccess(`Final version : ${version}`);
+      }
+
+      // if it's a branch new DEV stream release, the snapshot is itialized
+    } else {
+      version += '.0';
+    }
+  }
+
+  return version;
+}
+
+const getNewVersionForProd = (versionsMetadata, envsMetadata) => {
+  let version;
+
+  // get the last DEV version from env metadata
+  const lastAccVersion = envsMetadata['ACC'].version;
+
+  tools.logInfo(`Fetched last version from ACC : ${lastAccVersion}`);
+
+  // coerce the version (X.Y.Z-INT.n will generate : X.Y.Z)
+  const rootVersion = semver.coerce(lastAccVersion).raw;
+  const tempVersion = rootVersion.split('.');
+  const rootVersionMinor = `${tempVersion[0]}.${tempVersion[1]}`;
+
+  // check if the root version already exists
+  const prevVersions = versionsMetadata.versions.filter((v) => {
+    return v.version.indexOf(rootVersionMinor) > -1 && v.envTarget === 'PROD';
+  });
+
+  if (prevVersions.length) {
+    const lastVersion = prevVersions[prevVersions.length - 1];
+
+    tools.logInfo(`Version already found [${lastVersion.version}]`);
+    version = semver.inc(lastVersion.version, 'patch');
+    tools.logInfo(`Incremented version : ${version}`);
+
+  } else {
+    version = rootVersion;
+  }
+
+  tools.logSuccess(`Final version : ${version}`);
+
+  return version;
+}
+
+
+const getNewVersionForEnv = (versionsMetadata, envsMetadata, rootEnv, envTarget) => {
+  let version;
+
+  tools.logInfo(`Fetching version from rootEnv: ${rootEnv} for target: ${envTarget}`);
+
+  // check if envMetadata contains data for the rootEnv
+  if (!envsMetadata[rootEnv]) {
+    throw new Error(`No metadata found for rootEnv: ${rootEnv} for envTarget build: ${envTarget}`);
+  }
+
+  // get the last DEV version from env metadata
+  const lastRootEnvVersion = envsMetadata[rootEnv].version;
+
+  tools.logInfo(`Fetched last version from ${rootEnv} : ${lastRootEnvVersion}`);
+
+  // coerce the version (X.Y.Z-SNAPSHOT will generate : X.Y.Z)
+  const rootVersion = semver.coerce(lastRootEnvVersion).raw;
+
+  // check if the root version already exists
+  const prevVersions = versionsMetadata.versions.filter((v) => {
+    return v.version.indexOf(rootVersion) > -1 && v.envTarget === envTarget;
+  });
+
+  if (prevVersions.length) {
+    const lastVersion = prevVersions[prevVersions.length - 1];
+
+    tools.logInfo(`Version already found [${lastVersion.version}]`);
+    version = semver.inc(lastVersion.version, 'prerelease');
+    tools.logInfo(`Incremented version : ${version}`);
+
+  } else {
+    version = rootVersion + '-' + envTarget + '.0';
+  }
+
+  tools.logSuccess(`Final version : ${version}`);
+
+  return version;
+}
+
+
+
+
+module.exports.getNewVersionDefault = (envTarget, versionsMetadata, envsMetadata) => {
+  tools.logInfo(`Retrieve version for ${envTarget}`);
+
+  return Promise.resolve()
+    .then(() => {
+      let version;
+
+      // =====================================================================
+      // DEV target : format : X.Y.Z-SNAPSHOT.n
+      //  - where X.Y.Z is last INT release next MAJOR version
+      // =====================================================================
+
+      if (envTarget === 'DEV') {
+        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'INT');
+      }
+
+
+      // =====================================================================
+      // TST target : format : X.Y.Z-TST.n
+      //   - where X.Y.Z is the last root version of DEV env target
+      // =====================================================================
+
+      if (envTarget === 'TST') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'DEV', 'TST');
+      }
+
+
+      // =====================================================================
+      // INT target : format : X.Y.Z-INT.n
+      //   - where X.Y.Z is the last root version of TST env target
+      // =====================================================================
+
+      if (envTarget === 'INT') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'TST', 'INT');
+      }
+
+
+      // =====================================================================
+      // ACC target : format : X.Y.Z-envTarget.n
+      //   - where X.Y.Z is the last root version of INT env target
+      // =====================================================================
+
+      if (envTarget === 'ACC') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'INT', 'ACC');
+      }
+
+      // =====================================================================
+      // DLT targets : format : X.Y.Z-envTarget.n
+      //   - where X.Y.Z is the last root version of ACC env target
+      // =====================================================================
+
+      if (envTarget === 'DLT') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'ACC', 'DLT');
+      }
+
+      // =====================================================================
+      // TRN targets : format : X.Y.Z-envTarget.n
+      //   - where X.Y.Z is the last root version of PROD env target
+      // =====================================================================
+
+      if (envTarget === 'TRN') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'ACC', 'TRN');
+      }
+
+      // =====================================================================
+      // FOR PROD : format X.Y.Z(+1)
+      //   - where X.Y.Z is the last version of PROD with the same INT root
+      // =====================================================================
+
+      if (envTarget === 'PROD') {
+        version = getNewVersionForProd(versionsMetadata, envsMetadata);
+      }
+
+      // Check if version has been found, it can never be empty
+      if (!version) {
+        throw new Error(`Unable to generate version for ${envTarget}`);
+      }
+
+      return version;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+module.exports.getNewVersionDTAP = (envTarget, versionsMetadata, envsMetadata) => {
+  tools.logInfo(`Retrieve version for ${envTarget}`);
+
+  return Promise.resolve()
+    .then(() => {
+      let version;
+
+      // =====================================================================
+      // DEV target : format : X.Y.Z-SNAPSHOT.n
+      //  - where X.Y.Z is last INT release next MAJOR version
+      // =====================================================================
+
+      if (envTarget === 'DEV') {
+        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'TST');
+      }
+
+
+      // =====================================================================
+      // TST target : format : X.Y.Z-TST.n
+      //   - where X.Y.Z is the last root version of DEV env target
+      // =====================================================================
+
+      if (envTarget === 'TST') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'DEV', 'TST');
+      }
+
+
+      // =====================================================================
+      // ACC target : format : X.Y.Z-envTarget.n
+      //   - where X.Y.Z is the last root version of INT env target
+      // =====================================================================
+
+      if (envTarget === 'ACC') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'TST', 'ACC');
+      }
+
+
+      // =====================================================================
+      // FOR PROD : format X.Y.Z(+1)
+      //   - where X.Y.Z is the last version of PROD with the same INT root
+      // =====================================================================
+
+      if (envTarget === 'PROD') {
+        version = getNewVersionForProd(versionsMetadata, envsMetadata);
+      }
+
+      // Check if version has been found, it can never be empty
+      if (!version) {
+        throw new Error(`Unable to generate version for ${envTarget}`);
+      }
+
+      return version;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+