@eui/tools 5.0.0-rc.8 → 5.1.1

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,126 @@
+'use strict';
+
+// LOCALS
+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();
+
+// PRIVATES
+let authToken;
+
+
+const handleResponse = (response) => {
+  tools.logDebug(JSON.stringify(response));
+
+  if (response.ok) {
+    return response.data;
+  } else {
+    throw new Error(response.message);
+  }
+}
+
+module.exports.login = () => {
+  const fetch = require('node-fetch');
+
+  tools.logInfo(`API Login - userId:${apiUserId}`);
+
+  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) => {
+      tools.logDebugResponse(res);
+      return res.json();
+    })
+    .then((response) => {
+      authToken = response.token;
+      return handleResponse(response);
+    })
+    .catch(e => {
+      tools.logDebugTrace(__filename, 'login', e);
+      throw e;
+    });
+}
+
+
+module.exports.get = (pathName) => {
+  const fetch = require('node-fetch');
+
+  tools.logInfo(`API get - pathName: ${pathName}`);
+
+  return Promise.resolve()
+    .then(() => {
+      if (!authToken) {
+        return this.login();
+      }
+    })
+    .then(() => {
+      return fetch(`${API_HOST}${pathName}`, {
+        method: 'get',
+        headers: {
+          'content-type': 'application/json',
+          'x-auth-token': authToken
+        },
+      })
+    })
+    .then((res) => {
+      tools.logDebugResponse(res);
+      return res.json();
+    })
+    .then((response) => {
+      return handleResponse(response);
+    })
+    .catch(e => {
+      tools.logDebugTrace(__filename, 'get', e);
+      throw e;
+    });
+}
+
+
+module.exports.post = (pathName, body) => {
+  const fetch = require('node-fetch');
+
+  tools.logInfo(`API post - pathName: ${pathName} - body: ${JSON.stringify(body)}`);
+
+  return Promise.resolve()
+    .then(() => {
+      if (!authToken) {
+        return this.login();
+      }
+    })
+    .then(() => {
+      return fetch(`${API_HOST}${pathName}`, {
+        method: 'post',
+        headers: {
+          'content-type': 'application/json',
+          'x-auth-token': authToken
+        },
+        body: JSON.stringify(body)
+      })
+    })
+    .then((res) => {
+      tools.logDebugResponse(res);
+      return res.json();
+    })
+    .then((response) => {
+      return handleResponse(response);
+    })
+    .catch(e => {
+      tools.logDebugTrace(__filename, 'post', 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) {

package/scripts/utils/build/package/angular.js

@@ -14,19 +14,6 @@ const configUtils = require('../../../csdr/config/config-utils');
 let { deps, skipClean, skipLint, skipTest, skipCompile, skipDoc } = tools.getArgs();
 
 
-
-const preChecks = (pkg) => {
-  return Promise.resolve()
-    .then(() => {
-      return configUtils.angular.generateTsConfigLibProd(pkg);
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
 module.exports.build = (pkg, isMaster) => {
 
   tools.logInfo('Building UI Angular package...');
@@ -43,11 +30,6 @@ module.exports.build = (pkg, isMaster) => {
   }
 
   return Promise.resolve()
-    // disabled only used for injecting tsconfig.lib.prod for disable ivy using '--prod' flag if necessary in later version of angular / node
-    // .then(() => {
-    //   tools.logInfo('Executing pre-checks');
-    //   return preChecks(pkg);
-    // })
     .then(() => {
       if (deps === true) {
         tools.logInfo('Building dependencies...');
@@ -63,13 +45,7 @@ module.exports.build = (pkg, isMaster) => {
     .then(() => {
       if (!skipLint) {
         tools.logInfo('Linting...');
-
-        let tsLintPath;
-        if (pkg.build && pkg.build.euiVersion && pkg.build.euiVersion === '9.x') {
-          tsLintPath = path.join(pkg.paths.pkgRootDirectory, 'tslint-eui9.json');
-        } else {
-          tsLintPath = path.join(pkg.paths.pkgRootDirectory, 'tslint.json');
-        }
+        const tsLintPath = path.join(pkg.paths.pkgRootDirectory, 'tslint.json');
         const tsConfigPath = path.join(pkg.paths.pkgRootDirectory, 'tsconfig.lib.json');
         tools.logInfo(`running tslint -c ${tsLintPath} -p ${tsConfigPath}`);
         return tools.runScript(`tslint -c ${tsLintPath} -p ${tsConfigPath} -t verbose`);
@@ -82,11 +58,8 @@ module.exports.build = (pkg, isMaster) => {
       if (!skipTest) {
         tools.logInfo('Testing...');
         let args = ['--max_old_space_size=8096', ng, 'test', pkg.name];
-
         args.push('--code-coverage');
-
         tools.logInfo(`running ng test : with args: ${args} on folder : ${pkg.paths.pkgRootDirectory}`);
-
         return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
       }
     })
@@ -96,11 +69,9 @@ module.exports.build = (pkg, isMaster) => {
       }
       if (!skipCompile) {
         tools.logInfo('Bundling package...');
-
         let args = ['--max_old_space_size=8096', ng, 'build', pkg.name];
 
         tools.logInfo(`running ng build : with args: ${args} on folder : ${pkg.paths.pkgRootDirectory}`);
-
         return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
       }
     })
@@ -132,14 +103,17 @@ module.exports.build = (pkg, isMaster) => {
       if (!skipCompile) {
         tools.logInfo('Copying assets...');
         tools.copydir(path.join(pkg.paths.pkgRootDirectory, 'assets'), path.join(pkg.paths.pkgRootDirectory, 'dist', 'assets'));
+
         tools.logInfo('Copying config...');
         tools.copydir(path.join(pkg.paths.pkgRootDirectory, 'config'), path.join(pkg.paths.pkgRootDirectory, 'dist', 'config'));
+
         tools.logInfo('Copying license...');
         if (pkg.child) {
           tools.copy(path.join(pkg.paths.pkgRootDirectory, '..', '..', 'LICENSE'), path.join(pkg.paths.pkgRootDirectory, 'dist', 'LICENSE'));
         } else {
           tools.copy(path.join(pkg.paths.pkgRootDirectory, 'LICENSE'), path.join(pkg.paths.pkgRootDirectory, 'dist', 'LICENSE'));
         }
+
         tools.logInfo('Copying readme.md...');
         if (pkg.child) {
           tools.copy(path.join(pkg.paths.pkgRootDirectory, '..', '..', 'README.md'), path.join(pkg.paths.pkgRootDirectory, 'dist', 'README.md'));

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

@@ -3,11 +3,11 @@
 // GLOBAL
 const path = require('path');
 const glob = require('glob');
+const execa = require('execa');
 
 // LOCAL
 const tools = require('../../tools');
 const configUtils = require('../../../csdr/config/config-utils');
-const notificationUtils = require('../../notification/notification-utils');
 
 // INNER MODULES
 const innerNodeJs = require('./nodeJs');
@@ -188,3 +188,52 @@ module.exports.postBuild = (pkg) => {
     })
 }
 
+
+module.exports.buildSubEntry = (pkg, subEntry) => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logInfo(`Building sub-entry : ${subEntry} of package : ${pkg.name}`);
+      // console.log(pkg);
+      return tools.getFilesGlob(pkg.paths.pkgRootDirectory, `**/package.json`);
+    })
+
+    .then((files) => {
+      // console.log(files);
+
+      if (files.length === 0) {
+        tools.logWarning(`no sub-entries found within package ${pkg.name}`);
+        return;
+
+      } else {
+        let subEntryPath = files.filter((f) => {
+          return f.indexOf(subEntry) > -1;
+        })[0];
+
+        if (!subEntryPath) {
+          tools.logWarning(`${subEntry} can't be found in sub-folders of package (must contains package.json file for sub-entry definition)`);
+          return;
+
+        } else {
+          subEntryPath = subEntryPath.replace('/ng-package.json', '');
+          tools.logInfo(`${subEntryPath} found... injecting angular.json for sub entry`);
+
+          return configUtils.angular.registerAngularPackageSubEntry(subEntry, subEntryPath);
+        };
+      }
+    })
+
+    .then(() => {
+      const ng = path.resolve(process.cwd(), 'node_modules', '@angular', 'cli', 'bin', 'ng');
+
+      let args = ['--max_old_space_size=8096', ng, 'build', subEntry];
+
+      return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
+    })
+
+    .then(() => {
+      tools.logSuccess();
+    })
+    .catch((e) => {
+      throw e;
+    })
+}