@eui/tools 5.0.0-rc.2 → 5.0.0-rc.20

package/scripts/csdr/version/package-default.js

@@ -0,0 +1,144 @@
+'use strict';
+
+// externals
+const semver = require('semver');
+const path = require('path');
+
+// local
+const tools = require('../../utils/tools');
+
+
+const getCurrentVersion = (pkg) => {
+  return Promise.resolve()
+    .then(() => {
+      let currentVersion;
+
+      tools.logTitle('Extracting current version');
+
+      if (pkg.backend) {
+        // if nodejs backend, explicitely declared
+        if (pkg.build && pkg.build.nodejs) {
+          tools.logInfo('UI package => extracting from package.json');
+
+          const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
+          const pkgJson = require(pathPkgJson);
+          currentVersion = pkgJson.version;
+
+          // by default maven java backend is taken into account
+        } else {
+          tools.logInfo('Backend => extracting pom.xml');
+          const xmlContent = tools.getXMLJsContent(path.join(pkg.paths.pkgDirectory, 'pom.xml'));
+
+          tools.logInfo('Content found:');
+          console.log(xmlContent);
+
+          currentVersion = xmlContent.project.version.toString();
+        }
+
+      } else {
+        tools.logInfo('UI package => extracting from package.json');
+
+        const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
+        const pkgJson = require(pathPkgJson);
+        currentVersion = pkgJson.version;
+      }
+
+      tools.logSuccess('Current version found : ' + currentVersion);
+      return currentVersion;
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+const getReleaseType = (commitsMetadata) => {
+  tools.logInfo('Getting release type based on commits metadata parsed from last tag');
+
+  const RELEASE_TYPES = ['major', 'minor', 'patch'];
+
+  let level = 2;
+  let breakings = 0;
+  let features = 0;
+
+  commitsMetadata.forEach((commit) => {
+    if (commit.breakingChange) {
+      breakings += commit.body;
+      level = 1; // no major bump on "breaking changes"
+    } else if (commit.type === 'feat') {
+      features += 1;
+      if (level === 2) {
+        level = 1;
+      }
+    }
+  });
+
+  return {
+    level: level,
+    reason: 'There are ' + breakings + ' BREAKING CHANGES and ' + features + ' features',
+    releaseType: RELEASE_TYPES[level]
+  };
+}
+
+
+// PUBLIC METHODS
+
+module.exports.getNewVersion = (
+    pkg,
+    commits,
+    isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch
+  ) => {
+  return Promise.resolve()
+    .then(() => {
+      return getCurrentVersion(pkg);
+    })
+
+    .then((currentVersion) => {
+      tools.logTitle('Extracting recommended version');
+
+      tools.logInfo(`Current version found : ${currentVersion}`);
+
+      const release = getReleaseType(commits);
+      tools.logInfo('release info found : ' + JSON.stringify(release));
+
+      let newVersion = '1.0.0';
+
+      if (isNextBranch) {
+        newVersion = semver.inc(currentVersion, 'prerelease');
+      } else {
+        newVersion = semver.valid(release.releaseType) || semver.inc(currentVersion, release.releaseType)
+      }
+
+      tools.logInfo('probable new version : ' + newVersion);
+
+      if (isSnapshot) {
+        if (pkg.backend) {
+          if (pkg.build && pkg.build.nodejs) {
+            newVersion += '-snapshot-' + Date.now();
+          } else {
+            newVersion += '-SNAPSHOT';
+          }
+        } else {
+          newVersion += '-snapshot-' + Date.now();
+        }
+
+      } else if (isSupportBranch) {
+        if (pkg.backend) {
+          newVersion = semver.inc(currentVersion, 'prerelease');
+        }
+      } else if (isHotfixBranch) {
+        newVersion = semver.inc(currentVersion, 'prerelease');
+      }
+
+      tools.logSuccess('new version generated : ' + newVersion);
+
+      return newVersion;
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+

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

@@ -0,0 +1,51 @@
+'use strict';
+
+// externals
+const semver = require('semver');
+const path = require('path');
+const execa = require('execa');
+const fs = require('fs');
+
+// local
+const tools = require('../../utils/tools');
+const metadataUtils = require('../metadata/metadata-utils');
+
+// inner modules
+const innerCommon = require('./common');
+
+// constants
+const { dryRun } = tools.getArgs();
+
+
+// for env-based build, we take the latest TST release version as the base
+module.exports.getNewVersion = (pkg, envTarget) => {
+  let versionsMetadata;
+  let envsMetadata;
+
+  return Promise.resolve()
+    // fetch versions history and store
+    .then(() => {
+      return metadataUtils.packageVersions.getMetadata(pkg);
+    })
+    .then((metadata) => {
+      versionsMetadata = metadata;
+    })
+
+    // fetch envs metadata and store
+    .then(() => {
+      return metadataUtils.packageEnvs.getMetadata(pkg);
+    })
+    .then((metadata) => {
+      envsMetadata = metadata;
+    })
+
+
+    // generating new version based on the env target and the envs cycle type
+    .then(() => {
+      return innerCommon.getNewVersionDefault(envTarget, versionsMetadata, envsMetadata);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/version/package.js

@@ -1,283 +1,29 @@
 'use strict';
 
-// externals
-const semver = require('semver');
-const path = require('path');
-const execa = require('execa');
-const fs = require('fs');
-
-// local
-const tools = require('../../utils/tools');
-const templateUtils = require('../templates/template-utils');
-const configUtils = require('../config/config-utils');
-
-
-// constants
-const RELEASE_TYPES = ['major', 'minor', 'patch'];
-
-const { dryRun, nexusUser, nexusPassword } = tools.getArgs();
-
-
-const getCurrentVersion = (pkg) => {
+// inner modules
+const packageDefault = require('./package-default');
+const packageRemote = require('./package-remote');
+const packageCommon = require('./package-common');
+
+// public methods
+module.exports.getNewVersion = (
+    pkg,
+    commits,
+    isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch,
+    envTarget
+  ) => {
   return Promise.resolve()
     .then(() => {
-      let currentVersion;
-
-      tools.logTitle('Extracting current version');
-
-      if (pkg.backend) {
-        // if nodejs backend, explicitely declared
-        if (pkg.build && pkg.build.nodejs) {
-          tools.logInfo('UI package => extracting from package.json');
-
-          const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
-          const pkgJson = require(pathPkgJson);
-          currentVersion = pkgJson.version;
-
-          // by default maven java backend is taken into account
-        } else {
-          tools.logInfo('Backend => extracting pom.xml');
-
-          const xmlContent = tools.getXMLJsContent(path.join(pkg.paths.pkgDirectory, 'pom.xml'));
-          console.log(xmlContent);
-
-          currentVersion = xmlContent.project.version.toString();
-        }
-
+      if (pkg.remote && pkg.build && pkg.build.envTargetActive) {
+        return packageRemote.getNewVersion(pkg, envTarget);
       } else {
-        tools.logInfo('UI package => extracting from package.json');
-
-        const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
-        const pkgJson = require(pathPkgJson);
-        currentVersion = pkgJson.version;
-      }
-
-      tools.logSuccess('Current version found : ' + currentVersion);
-      return currentVersion;
-    })
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-const writePackageJsonCore = (newVersion, folder, isSnapshot, isNextBranch, isSupportBranch) => {
-  return Promise.resolve()
-    .then(() => {
-      const pkgJsonFile = path.resolve(folder, 'package.json');
-      const pkgJson = require(pkgJsonFile);
-
-      let tag = 'latest';
-
-      if (isSnapshot) {
-        tag = 'snapshot';
-      }
-      if (isNextBranch) {
-        tag = 'next';
-      }
-      if (isSupportBranch) {
-        tag = 'prev';
-      }
-
-      pkgJson.version = newVersion;
-      pkgJson.tag = tag;
-
-      tools.logInfo(`Updating package version : ${newVersion} / tag: ${tag} for ${pkgJsonFile}`);
-      tools.writeJsonFileSync(pkgJsonFile, pkgJson);
-    })
-    .catch((e) => {
-      throw e;
-    })
-}
-
-const writePackageJson = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch) => {
-  return Promise.resolve()
-    .then(() => {
-      tools.logTitle('updating package version');
-
-      if (!pkg.parent) {
-        return Promise.resolve()
-          .then(() => {
-            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch);
-          })
-          .then(() => {
-            if (!pkg.element && !pkg.config) {
-              return writePackageJsonCore(newVersion, pkg.paths.pkgPublish, isSnapshot, isNextBranch, isSupportBranch);
-            }
-          })
-          .catch((e) => {
-            throw e;
-          })
-
-      } else {
-        return Promise.resolve()
-          .then(() => {
-            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch);
-          })
-          .then(() => {
-            let linkedPackages = Object.keys(pkg.packages)
-              .map(p => {
-                const pkg = configUtils.packages.getPackage(p);
-                return pkg;
-              })
-
-            return tools.removeArrayDuplicates(linkedPackages, 'name');
-          })
-
-          .then((linkedPackages) => Promise.resolve().then(() => {
-            return linkedPackages.reduce((promise, pkg) => {
-              return promise.then(() => (
-                writePackageJsonCore(newVersion, pkg.paths.pkgPublish, isSnapshot, isNextBranch, isSupportBranch)
-              ));
-            }, Promise.resolve());
-          }))
-
-          .catch((e) => {
-            throw e;
-          })
-      }
-    })
-    .then(() => {
-      tools.logSuccess();
-    })
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-
-const writePomXml = (pkg, newVersion, isSnapshot, isForceTimestamp = true) => {
-
-  tools.logTitle(`updating project pom.xml version: ${newVersion}`);
-
-  return Promise.resolve()
-    .then(() => {
-      return templateUtils.generateMavenSettings(nexusUser, nexusPassword);
-    })
-
-    .then((mavenSettingsFile) => {
-
-      tools.logInfo(`Executing mvn versions on : ${pkg.paths.pkgDirectory}`);
-
-      execa.shellSync('mvn versions:set -T1 -DnewVersion=' + newVersion + ' -s ' + mavenSettingsFile, { cwd: pkg.paths.pkgDirectory });
-      execa.shellSync('mvn versions:commit -T1' + ' -s ' + mavenSettingsFile, { cwd: pkg.paths.pkgDirectory });
-
-      if (isForceTimestamp) {
-        // timestamp file is forced to have at least one file to commit, as snapshot release
-        // for backend can keep the same version until its latest
-        const tsversionFile = path.resolve(pkg.paths.pkgDirectory, '.tsversion');
-        fs.writeFileSync(tsversionFile, Date.now());
-
-        const versionFile = path.resolve(pkg.paths.pkgDirectory, '.version.properties');
-        fs.writeFileSync(versionFile, newVersion);
+        return packageDefault.getNewVersion(pkg, commits, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
       }
     })
-    .then(() => {
-      tools.logSuccess();
-    })
-    .catch((e) => {
-      throw e;
-    })
-}
-
 
-
-
-
-// PUBLIC METHODS
-
-module.exports.getNewVersion = (pkg, commits, isSnapshot, isNextBranch, isSupportBranch) => {
-  return Promise.resolve()
-    .then(() => {
-      return getCurrentVersion(pkg);
-    })
-
-    .then((currentVersion) => {
-      tools.logTitle('Extracting recommended version');
-
-      tools.logInfo(`Current version found : ${currentVersion}`);
-
-      let newVersion = '1.0.0';
-
-      if (commits) {
-
-        tools.logInfo('Commits found for processing version, extracting...');
-
-        let level = 2;
-        let breakings = 0;
-        let features = 0;
-
-        commits.forEach((commit) => {
-          if (commit.breakingChange) {
-            breakings += commit.body;
-            level = 0;
-          } else if (commit.type === 'feat') {
-            features += 1;
-            if (level === 2) {
-              level = 1;
-            }
-          }
-        });
-
-        const release = {
-          level: level,
-          reason: 'There are ' + breakings + ' BREAKING CHANGES and ' + features + ' features',
-          releaseType: RELEASE_TYPES[level]
-        };
-
-        tools.logInfo('release info found : ' + JSON.stringify(release));
-
-        if (isNextBranch) {
-          newVersion = semver.inc(currentVersion, 'prerelease');
-        } else {
-          newVersion = semver.valid(release.releaseType) || semver.inc(currentVersion, release.releaseType)
-        }
-
-
-      } else {
-          tools.logInfo('No commits found for version processing...applying minor version upgrade');
-
-          if (isNextBranch) {
-            newVersion = semver.inc(currentVersion, 'prerelease');
-          } else {
-            newVersion = semver.inc(currentVersion, 'minor');
-          }
-      }
-
-      tools.logInfo('probable new version : ' + newVersion);
-
-      if (isSnapshot) {
-        if (pkg.backend) {
-          if (pkg.build && pkg.build.nodejs) {
-            newVersion += '-snapshot-' + Date.now();
-          } else {
-            newVersion += '-SNAPSHOT';
-          }
-        } else {
-          newVersion += '-snapshot-' + Date.now();
-        }
-      }
-
-      if (isSupportBranch && pkg.backend) {
-        newVersion = semver.inc(currentVersion, 'prerelease');
-      }
-
-      tools.logSuccess('new version generated : ' + newVersion);
-
-      return newVersion;
-    })
     .catch((e) => {
       throw e;
     })
 }
 
-
-module.exports.updateVersion = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch) => {
-  if (pkg.backend) {
-    return writePomXml(pkg, newVersion, isSnapshot);
-  }
-  else {
-    return writePackageJson(pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch);
-  }
-}
+module.exports.updateVersion = packageCommon.updateVersion;

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

@@ -1,16 +1,21 @@
 'use strict';
 
-// externals
-const moment = require('moment');
-
-// local
-const tools = require('../../utils/tools');
-
 // inner modules
 const innerApp = require('./app');
+const innerAppCommon = require('./app-common');
+const innerAppDefault = require('./app-default');
+const innerAppEnvTarget = require('./app-env-target');
 const innerPackage = require('./package');
+const innerPackageCommon = require('./package-common');
+const innerPackageRemote = require('./package-remote');
+const innerPackageDefault = require('./package-default');
 
 // re-exports inner modules
 module.exports.app = innerApp;
+module.exports.appCommon = innerAppCommon;
+module.exports.appDefault = innerAppDefault;
+module.exports.appEnvTarget = innerAppEnvTarget;
 module.exports.package = innerPackage;
-
+module.exports.packageCommon = innerPackageCommon;
+module.exports.packageRemote = innerPackageRemote;
+module.exports.packageDefault = innerPackageDefault;

package/scripts/utils/api-utils.js

@@ -0,0 +1,90 @@
+'use strict';
+
+// GLOBALS
+const fetch = require('node-fetch');
+
+// LOCAL
+const tools = require('./tools');
+const configUtils = require('../csdr/config/config-utils');
+
+// FETCH OPTIONS
+const { API_HOST } = configUtils.global.getConfigOptions();
+
+// FETCH ARGS
+const { apiUserId, apiPassword } = tools.getArgs();
+
+// GLOBALS
+let authToken;
+
+module.exports.login = () => {
+  return Promise.resolve()
+    .then(() => {
+      return fetch(`${API_HOST}/auth`, {
+        method: 'post',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            "userid": apiUserId,
+            "password": apiPassword
+        })
+      })
+    })
+    .then((res) => {
+      return res.json();
+    })
+    .then((response) => {
+      authToken = response.token;
+      return response;
+    })
+    .catch(e => {
+      throw e;
+    });
+}
+
+
+module.exports.get = (scope) => {
+  return Promise.resolve()
+    .then(() => {
+      return fetch(`${API_HOST}/${scope}`, {
+        method: 'get',
+        headers: {
+          'content-type': 'application/json',
+          'x-auth-token': authToken
+        },
+      })
+    })
+    .then((res) => {
+      return res.json();
+    })
+    .then((response) => {
+      return response;
+    })
+    .catch(e => {
+      throw e;
+    });
+}
+
+module.exports.post = (scope, body) => {
+  return Promise.resolve()
+    .then(() => {
+      return fetch(`${API_HOST}/${scope}`, {
+        method: 'post',
+        headers: {
+          'content-type': 'application/json',
+          'x-auth-token': authToken
+        },
+        body: JSON.stringify(body)
+      })
+    })
+    .then((res) => {
+      return res.json();
+    })
+    .then((response) => {
+      return response;
+    })
+    .catch(e => {
+      throw e;
+    });
+}
+
+
+

package/scripts/utils/build/app/build-app-utils.js

@@ -13,7 +13,7 @@ const preBuildUtils = require('../../pre-build/pre-build-utils');
 let {
   skipLint, skipTest, skipCompile, configuration, baseHref,
   watch, dryRun, maxSpaceSize, statsJson, extraWebpackConfig, ci,
-  deployUrl, sourceMap
+  deployUrl, sourceMap, configEnvTarget
 } = tools.getArgs();
 
 
@@ -33,12 +33,18 @@ const getProjectInfos = () => {
 
 
 
-module.exports.angular = (envTarget, isSnapshot, version) => {
+module.exports.angular = (envTarget, isSnapshot, version, configEnvTargetIn) => {
 
   const ng = path.resolve(process.cwd(), 'node_modules', '@angular', 'cli', 'bin', 'ng');
 
   const currentProject = getProjectInfos();
 
+  // checking if configEnvTarget is passed as param, if not take the global script param
+  // as this angular build method can be called in stand-alone (outside of CSDR pipeline flow)
+  if (configEnvTargetIn) {
+    configEnvTarget = configEnvTargetIn;
+  }
+
   // getting param from project config
   if (currentProject.build) {
     if (currentProject.build.skipLint) {
@@ -66,7 +72,7 @@ module.exports.angular = (envTarget, isSnapshot, version) => {
     })
 
     .then(() => {
-      return preBuildUtils.projects.preBuild(currentProject, envTarget, true);
+      return preBuildUtils.projects.preBuild(currentProject, envTarget, true, configEnvTarget);
     })
 
     .then(() => {
@@ -88,10 +94,6 @@ module.exports.angular = (envTarget, isSnapshot, version) => {
       if (!skipLint) {
         tools.logSuccess();
       }
-      if (!skipLint) {
-        tools.logInfo(`Styles Linting application...`);
-        return tools.runScript(`stylelint **/*.scss`, currentProject.paths.angularPath);
-      }
     })
 
 
@@ -120,7 +122,7 @@ module.exports.angular = (envTarget, isSnapshot, version) => {
 
         tools.logInfo(`ng test : watching = ${watch || false}`);
 
-        console.log(`running Angular TEST with args: ${args} on`);
+        tools.logInfo(`running Angular TEST with args: ${args} on :`);
         console.log(currentProject.paths.angularPath);
 
         if (!dryRun) {
@@ -204,7 +206,7 @@ module.exports.angular = (envTarget, isSnapshot, version) => {
 
       tools.logInfo(`ng build for configuration : ${configuration || 'production'}`);
 
-      console.log(`running Angular BUILD with args: ${args} on`);
+      tools.logInfo(`running Angular BUILD with args: ${args} on :`);
       console.log(currentProject.paths.angularPath);
 
       if (!dryRun && !skipCompile) {