@eui/tools 4.21.10 → 5.0.0-rc.12

package/scripts/csdr/version/package.js

@@ -1,288 +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) => {
-  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 writePackageJsonCore = (newVersion, folder, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch) => {
-  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, isHotfixBranch) => {
+// 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(() => {
-      tools.logTitle('updating package version');
-
-      if (!pkg.parent) {
-        return Promise.resolve()
-          .then(() => {
-            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
-          })
-          .then(() => {
-            if (!pkg.element && !pkg.config) {
-              return writePackageJsonCore(newVersion, pkg.paths.pkgPublish, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
-            }
-          })
-          .catch((e) => {
-            throw e;
-          })
-
+      if (pkg.remote && pkg.build && pkg.build.envTargetActive) {
+        return packageRemote.getNewVersion(pkg, envTarget);
       } else {
-        return Promise.resolve()
-          .then(() => {
-            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
-          })
-          .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, isHotfixBranch)
-              ));
-            }, 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, isHotfixBranch) => {
-  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 = 1; // no major bump on "breaking changes"
-          } 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');
-      }
-
-      if (isHotfixBranch) {
-        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, isHotfixBranch) => {
-  if (pkg.backend) {
-    return writePomXml(pkg, newVersion, isSnapshot);
-  }
-  else {
-    return writePackageJson(pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
-  }
-}
+module.exports.updateVersion = packageCommon.updateVersion;

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/package/nodeJs.js

@@ -23,7 +23,8 @@ module.exports.build = (pkg, isMaster) => {
   return Promise.resolve()
     .then(() => {
       if (!skipTest) {
-        return testUtils.runJest(pkg);
+        // return testUtils.runJest(pkg);
+        return testUtils.runMocha(pkg);
       }
     })
 

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

@@ -6,7 +6,7 @@ const tools = require('../tools');
 
 const translationUtils = require('./translations/translation-utils');
 const configUtils = require('../../csdr/config/config-utils');
-
+const injectionUtils = require('./injection/injection-utils');
 
 module.exports.preBuild = (pkg, build = false) => {
   return Promise.resolve()
@@ -19,6 +19,13 @@ module.exports.preBuild = (pkg, build = false) => {
       return configUtils.angular.registerAngularProjectDef(pkg);
     })
 
+    // inject external app sources declaration
+    .then(() => {
+      if (pkg.externalSources) {
+        return injectionUtils.externals.injectElementExternalSources(pkg);
+      }
+    })
+
     .then(() => {
       tools.logInfo('Checking compiled translations');
       if (pkg.build && pkg.build.compiledTranslations) {
@@ -34,13 +41,6 @@ module.exports.preBuild = (pkg, build = false) => {
       }
     })
 
-    // inject external app sources declaration
-    .then(() => {
-      if (pkg.externalSources) {
-        return injectionUtils.externals.injectElementExternalSources(pkg);
-      }
-    })
-
     .catch((e) => {
       throw e;
     })

package/scripts/utils/pre-build/injection/config.js

@@ -70,7 +70,7 @@ const injectPackagesConfig = (project) => {
 
     // fetching current project linked composite packages dependencies
     .then(() => {
-      return installUtils.compositeUtils.getLocalProjectsDeps(project);
+      return installUtils.common.getLocalProjectsDeps(project);
     })
 
 

package/scripts/utils/pre-build/injection/externals.js

@@ -107,10 +107,18 @@ module.exports.injectExternalAppSources = (project) => {
 
         } else {
           tools.logInfo(`Removing ${projectSrcPath} content`);
-          tools.rmdirFull(projectSrcPath, false);
 
-          tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
-          return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
+          return Promise.resolve()
+            .then(() => {
+              return tools.rmdirFull(projectSrcPath, false);
+            })
+            .then(() => {
+              tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
+              return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
+            })
+            .catch((e) => {
+              throw e;
+            })
         }
       }
     })
@@ -142,7 +150,7 @@ module.exports.injectElementExternalSources = (pkg) => {
         })[0];
 
         let externalSourcesSrcPath;
-        const pkgSrcPath = path.join(process.cwd(), pkg.folder, 'src');
+        const pkgSrcPath = path.join(pkg.paths.pkgRootDirectory, 'src');
 
         // if local package is found
         if (localPackage) {
@@ -163,8 +171,10 @@ module.exports.injectElementExternalSources = (pkg) => {
           throw new Error('External sources not found');
 
         } else {
-          tools.logInfo(`Removing ${pkgSrcPath} content`);
-          tools.rmdirFull(pkgSrcPath, false);
+          if (tools.isDirExists(pkgSrcPath)) {
+            tools.logInfo(`Removing ${pkgSrcPath} content`);
+            tools.rmdirFull(pkgSrcPath, false);
+          }
 
           tools.logInfo(`${externalSourcesSrcPath} injecting in ${pkgSrcPath}`);
           return tools.copydir(externalSourcesSrcPath, pkgSrcPath, true);

package/scripts/utils/test/test-utils.js

@@ -9,7 +9,7 @@ const tools = require('../tools');
 const configUtils = require('../../csdr/config/config-utils');
 
 // FETCH ARGS
-const { watch, skipCoverage } = tools.getArgs();
+const { watch, skipCoverage, timeout, build } = tools.getArgs();
 
 
 
@@ -84,3 +84,41 @@ module.exports.runJest = (pkg) => {
       throw e;
     })
 }
+
+
+module.exports.runMocha = (pkg) => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logTitle(`Executing Mocha test for pkg: ${pkg.name}`);
+
+      // set jest binary
+      const mocha = path.resolve(process.cwd(), 'node_modules', 'mocha', 'bin', 'mocha');
+      const nyc = path.resolve(process.cwd(), 'node_modules', 'nyc', 'bin', 'nyc');
+
+      // default arguments
+      let args;
+
+      if (!skipCoverage && !build) {
+        args = [nyc, '--reporter=text', mocha, pkg.paths.pkgFromRoot +  '/**/*.test.js'];
+      } else {
+        args = [mocha, pkg.paths.pkgFromRoot +  '/**/*.test.js'];
+      }
+      if (watch) {
+        args.push('--watch');
+      }
+      if (timeout) {
+        args.push(`--timeout ${timeout}`);
+      } else {
+        args.push('--timeout 5000');
+      }
+
+      return execa('node', args, { cwd: process.cwd(), stdio: 'inherit' });
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+