@eui/tools 5.0.0-rc.7 → 5.1.0

package/scripts/csdr/release/package/common.js

@@ -1,6 +1,7 @@
 'use strict';
 
 // GLOBAL
+const path = require('path');
 
 // UTILS
 const utils = require('../../../utils');
@@ -14,14 +15,15 @@ const { dryRun } = utils.tools.getArgs();
 
 
 
-module.exports.getBranches = () => {
+const getBranches = module.exports.getBranches = () => {
   const { branch } = utils.tools.getArgs();
 
   const isSnapshot =  (branch === 'develop');
   const isMaster =  (branch === 'master');
-  const isSupport = (!isMaster && !isSnapshot && branch.indexOf('support/') > -1);
-  const isNext = (!isMaster && !isSnapshot && !isSupport && branch.indexOf('next/') > -1);
-  const isSupportSnapshot = (!isMaster && !isSnapshot && !isSupport && !isNext);
+  const isSupportSnapshot = (!isMaster && !isSnapshot && branch.indexOf('support/develop') > -1);
+  const isSupport = (!isMaster && !isSnapshot && !isSupportSnapshot && branch.indexOf('support/') > -1);
+  const isHotfix = (!isMaster && !isSnapshot && !isSupportSnapshot && !isSupport && branch.indexOf('hotfix/') > -1);
+  const isNext = (!isMaster && !isSnapshot && !isSupport && !isSupportSnapshot && !isHotfix && branch.indexOf('next/') > -1);
 
   return {
     isSupport: isSupport,
@@ -29,12 +31,56 @@ module.exports.getBranches = () => {
     isNext: isNext,
     isSnapshot: isSnapshot,
     isMaster: isMaster,
+    isHotfix: isHotfix,
     branch: branch
   }
 }
 
+module.exports.getEnvTarget = () => {
+  const { envTarget } = utils.tools.getArgs();
 
-module.exports.init = (pkg) => {
+  // Initialize composite type
+  if (envTarget && typeof (envTarget) === 'boolean') {
+    envTarget = null;
+  }
+
+  let envTargetGen;
+
+  // when envTarget is provided this take the lead
+  if (envTarget) {
+    envTargetGen = envTarget;
+
+  // otherwise the envTarget is derived from branches develop = DEV/ master = TST
+  } else {
+    const branches = getBranches();
+    if (branches.isSnapshot || branches.isSupportSnapshotBranch) {
+      envTargetGen = 'DEV';
+    } else {
+      envTargetGen = 'TST';
+    }
+  }
+
+  return envTargetGen;
+}
+
+module.exports.getCompositeType = () => {
+  let { compositeType } = utils.tools.getArgs();
+
+  // Initialize composite type
+  if (compositeType && typeof (compositeType) === 'boolean') {
+    compositeType = null;
+  }
+
+  if (!compositeType) {
+    compositeType = 'DEFAULT';
+  }
+
+  return compositeType;
+}
+
+
+module.exports.init = (pkg, envTarget, compositeType) => {
+  utils.tools.logBanner('INIT');
 
   const branches = this.getBranches();
 
@@ -59,9 +105,17 @@ module.exports.init = (pkg) => {
 
     console.log(pkg);
 
+    let launchMessage = ':arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward:';
+
+    if (pkg.remote) {
+      launchMessage += ` Launching remote *${pkg.name}* release for ENV: *${envTarget}* - compositeType: *${compositeType}*`;
+    } else {
+      launchMessage += ` Launching *${pkg.name}* release for branch *${branches.branch}*`;
+    }
+
     return utils.notification.package.sendPackageMessage({
       package: pkg,
-      text: `:arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: Launching *${pkg.name}* release for branch *${branches.branch}*`
+      text: launchMessage
     });
   })
 
@@ -71,6 +125,11 @@ module.exports.init = (pkg) => {
     return metadataUtils.common.cloneMetadataRepo();
   })
 
+  // CLONE METADATA LOCKS REPO
+  .then(() => {
+    return metadataUtils.common.cloneMetadataLocksRepo();
+  })
+
   .catch((e) => {
     throw e;
   })
@@ -82,6 +141,8 @@ module.exports.init = (pkg) => {
 
 
 module.exports.preReleaseChecks = (pkg) => {
+  utils.tools.logBanner('PRE-RELEASE checks');
+
   return Promise.resolve()
 
   // GET AND CHECK DEVOPS CONFIG
@@ -112,6 +173,8 @@ module.exports.preReleaseChecks = (pkg) => {
 
 
 module.exports.commitMetadataChecks = (pkg) => {
+  utils.tools.logBanner('COMMIT METADATA CHECKS');
+
   utils.tools.logTitle('Checking package commit metadata');
   let pkgMetadata;
 
@@ -146,6 +209,8 @@ module.exports.commitMetadataChecks = (pkg) => {
 
 
 module.exports.preBuild = (pkg) => {
+  utils.tools.logBanner('PRE-BUILD');
+
   return Promise.resolve()
   .then(() => {
     return utils.buildPackage.preBuild(pkg);
@@ -159,7 +224,8 @@ module.exports.preBuild = (pkg) => {
 
 
 
-module.exports.updateVersion = (pkg, pkgMetadata) => {
+module.exports.updateVersion = (pkg, pkgMetadata, envTarget) => {
+  utils.tools.logBanner('UPDATE VERSION');
 
   // getting branch flags
   const branches = this.getBranches();
@@ -171,7 +237,15 @@ module.exports.updateVersion = (pkg, pkgMetadata) => {
 
   // GET NEW VERSION from VALID commits found in metadata
   .then(() => {
-    return versionUtils.package.getNewVersion(pkg, pkgMetadata.commits, branches.isSnapshot, branches.isNext, branches.isSupport);
+    return versionUtils.package.getNewVersion(
+      pkg,
+      pkgMetadata.commits,
+      (branches.isSnapshot || branches.isSupportSnapshot),
+      branches.isNext,
+      branches.isSupport,
+      branches.isHotfix,
+      envTarget
+    );
   })
 
 
@@ -179,9 +253,14 @@ module.exports.updateVersion = (pkg, pkgMetadata) => {
   .then((version) => {
     newVersion = version;
 
-    if (!dryRun) {
-      return versionUtils.package.updateVersion(pkg, version, branches.isSnapshot, branches.isNext, branches.isSupport);
-    }
+    return versionUtils.package.updateVersion(
+      pkg,
+      version,
+      (branches.isSnapshot || branches.isSupportSnapshot),
+      branches.isNext,
+      branches.isSupport,
+      branches.isHotfix
+    );
   })
 
   // returning new version generated
@@ -198,6 +277,8 @@ module.exports.updateVersion = (pkg, pkgMetadata) => {
 
 
 module.exports.generateChangelog = (pkg, version, pkgMetadata) => {
+  utils.tools.logBanner('GENERATE CHANGELOG');
+
   return Promise.resolve()
 
   // GENERATE CHANGELOG
@@ -232,6 +313,8 @@ module.exports.generateChangelog = (pkg, version, pkgMetadata) => {
 
 
 module.exports.postBuild = (pkg, version) => {
+  utils.tools.logBanner('POST BUILD');
+
   return Promise.resolve()
   // all packages
   .then(() => {
@@ -252,12 +335,25 @@ module.exports.postBuild = (pkg, version) => {
 }
 
 
-module.exports.runGitOperations = (pkg, version) => {
-
-  const branches = this.getBranches();
+module.exports.storeMetadataAssets = (pkg, pkgCompositeDeps) => {
+  utils.tools.logBanner('STORE METADATA ASSETS');
 
   return Promise.resolve()
+    .then(() => {
+      if (pkg.remote) {
+        return metadataUtils.package.storeMetadataAssets(pkg, pkgCompositeDeps);
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+const commitPackage = (pkg, version, branches) => {
   // COMMIT and PUSH UPDATED FILES ON PACKAGE REPOSITORY
+  return Promise.resolve()
   .then(() => {
     return utils.git.commitAndPush(
       branches.branch,
@@ -265,10 +361,17 @@ module.exports.runGitOperations = (pkg, version) => {
       pkg.paths.pkgDirectory
     );
   })
+  .catch((e) => {
+    throw e;
+  })
+}
+
 
+const tagAndMerge = (pkg, version, branches) => {
+  return Promise.resolve()
   // TAG THE NEW RELEASE (MASTER) for MASTER and SUPPORT
   .then(() => {
-    if (!branches.isSnapshot) {
+    if (!branches.isSnapshot && !branches.isSupportSnapshot) {
       return utils.git.tagVersion(
         version, branches.branch,
         `chore(release): tagging ${version} - from CI server`,
@@ -280,10 +383,19 @@ module.exports.runGitOperations = (pkg, version) => {
   // MERGE BACK ON DEVELOP for MASTER / LATEST RELEASE
   .then(() => {
     if (branches.isMaster) {
+      utils.tools.logInfo('Branch is master merge back to develop');
       return utils.git.mergeMasterToDevelop(pkg, pkg.paths.pkgDirectory, version);
     }
   })
 
+  // MERGE BACK ON support/develop for support release for package that has a support/develop branch active
+  .then(() => {
+    if (branches.isSupport && pkg.build && pkg.build.supportSnapshotBranch) {
+      utils.tools.logInfo('Branch is support / supportSnapshotBranch config detected');
+      return utils.git.mergeSupportToSupportDevelop(pkg, pkg.paths.pkgDirectory, branches.branch, pkg.build.supportSnapshotBranch);
+    }
+  })
+
   .catch((e) => {
     throw e;
   })
@@ -291,16 +403,54 @@ module.exports.runGitOperations = (pkg, version) => {
 
 
 
-module.exports.storeMetadata = (pkg, version, pkgMetadata, pkgCompositeDeps, duration) => {
+module.exports.runGitOperations = (pkg, version) => {
+  utils.tools.logBanner('RUN GIT OPERATIONS');
+
+  const branches = this.getBranches();
+  console.log(branches);
+
+  if (pkg.remote && pkg.build && pkg.build.envTargetActive) {
+    utils.tools.logInfo('Remote - with envTargetActive set - commit package only');
+
+    return Promise.resolve()
+    .then(() => {
+      return commitPackage(pkg, version, branches);
+    })
+    .catch((e) => {
+      throw e;
+    })
+
+  } else {
+    utils.tools.logInfo('Normal UI package - commit package, tagging and do merge operations if needed');
+
+    return Promise.resolve()
+    .then(() => {
+      return commitPackage(pkg, version, branches);
+    })
+    .then(() => {
+      return tagAndMerge(pkg, version, branches);
+    })
+    .catch((e) => {
+      throw e;
+    })
+  }
+}
+
+
+
+module.exports.storeMetadata = (pkg, version, pkgMetadata, pkgCompositeDeps, duration, envTarget) => {
+  utils.tools.logBanner('STORE METADATA');
+
   const branches = this.getBranches();
 
   return Promise.resolve()
   .then(() => {
     return metadataUtils.package.storeMetadata(
       pkg, version, pkgMetadata,
-      branches.isSnapshot, branches.isMaster, branches.isSupport, branches.isNext, branches.isSupportSnapshot,
+      branches.isSnapshot, branches.isMaster, branches.isSupport, branches.isNext, branches.isSupportSnapshot, branches.isHotfix,
       pkgCompositeDeps,
-      duration
+      duration,
+      envTarget
     );
   })
 
@@ -310,7 +460,53 @@ module.exports.storeMetadata = (pkg, version, pkgMetadata, pkgCompositeDeps, dur
 }
 
 
+module.exports.exportPipelineVariables = (pkg, compositeType) => {
+  utils.tools.logBanner('EXPORT PIPELINE VARIABLES');
+
+  let variablesContent = '';
+
+  return Promise.resolve()
+  .then(() => {
+    if (pkg.remote) {
+      utils.tools.logTitle('Exporting pkg remote variables');
+
+      utils.tools.logInfo('Exporting APP_TARGET');
+
+      let appTarget = 'MWP_ONLY';
+
+      if (pkg.build && pkg.build.appTarget) {
+        appTarget = pkg.build.appTarget;
+      }
+
+      utils.tools.logInfo(`appTarget generated : ${appTarget}`);
+
+      variablesContent += `export APP_TARGET=${appTarget}\n`;
+
+      if (compositeType) {
+        utils.tools.logInfo(`Exporting COMPOSITE_TYPE : ${compositeType}`);
+        variablesContent += `export COMPOSITE_TYPE=${compositeType}\n`;
+      }
+
+      if (dryRun) {
+        utils.tools.logWarning('dryRun...skipping export');
+      } else {
+        utils.tools.logInfo('Exporting appTarget variable');
+        return utils.pipeline.setVariables(pkg.paths.rootDirectory, variablesContent);
+      }
+    }
+  })
+
+  .catch((e) => {
+    throw e;
+  })
+}
+
+
+
+
 module.exports.generateDiffReport = (pkg, newVersion) => {
+  utils.tools.logBanner('GENERATE DIFF REPORT');
+
   const branches = this.getBranches();
 
   return Promise.resolve()
@@ -346,6 +542,8 @@ module.exports.generateDiffReport = (pkg, newVersion) => {
 
 
 module.exports.sendSuccessNotification = (pkg, version, pkgMetadata) => {
+  utils.tools.logBanner('SEND SUCCESS NOTIFICATION');
+
   return Promise.resolve()
   .then(() => {
     utils.tools.logTitle('Sending slack success');
@@ -381,6 +579,10 @@ module.exports.sendSuccessNotification = (pkg, version, pkgMetadata) => {
 
 
 module.exports.sendErrorNotification = (pkg, exception, pkgMetadata) => {
+  utils.tools.logBanner('SEND ERROR NOTIFICATION');
+
+  // console.log(pkgMetadata);
+
   return Promise.resolve()
   .then(() => {
     utils.tools.logTitle('ERROR !!!!! an unexpected error occured....');

package/scripts/csdr/release/package/release-package.js

@@ -14,6 +14,7 @@ const metadataUtils = require('../../metadata/metadata-utils');
 const innerCommon = require('./common');
 const innerUi = require('./ui');
 const innerRemote = require('./remote');
+const innerBackend = require('./backend');
 
 
 module.exports.run = () => {
@@ -30,16 +31,26 @@ module.exports.run = () => {
     // Get branches flags
     const branches = innerCommon.getBranches();
 
+    // Get envTarget (used by remotes)
+    const envTarget = innerCommon.getEnvTarget();
+
+    // Get compositeType (used by remotes)
+    const compositeType = innerCommon.getCompositeType();
+
+
     // local saved vars
     var newVersion, pkgMetadata, pkgCompositeDeps;
 
 
-
     return Promise.resolve()
+      .then(() => {
+        utils.tools.logVersion();
+      })
+
 
       // RELEASE PACKAGE START
       .then(() => {
-        return innerCommon.init(pkg);
+        return innerCommon.init(pkg, envTarget, compositeType);
       })
 
 
@@ -74,10 +85,13 @@ module.exports.run = () => {
       // INSTALL dependencies by type
       .then(() => {
         if (pkg.remote) {
-          return innerRemote.install(pkg, branches.isMaster);
+          return innerRemote.install(pkg, envTarget, compositeType);
+
+        } else if (pkg.backend) {
+          return innerBackend.install(pkg);
 
         } else {
-          return innerUi.install(pkg, branches.isMaster);
+          return innerUi.install(pkg);
         }
       })
       .then((compositeDeps) => {
@@ -100,7 +114,7 @@ module.exports.run = () => {
 
       // GENERATE and UPDATE new version
       .then(() => {
-        return innerCommon.updateVersion(pkg, pkgMetadata);
+        return innerCommon.updateVersion(pkg, pkgMetadata, envTarget);
       })
       .then((version) => {
         // storing version for later use
@@ -122,6 +136,12 @@ module.exports.run = () => {
       })
 
 
+      // STORING METADATA ASSETS
+      .then(() => {
+        return innerCommon.storeMetadataAssets(pkg, pkgCompositeDeps);
+      })
+
+
       // PUBLISH PACKAGE
       .then(() => {
         return utils.publish.publish(pkg);
@@ -144,15 +164,13 @@ module.exports.run = () => {
       .then(() => {
         // get run duration
         const duration = utils.pipeline.getTimerDuration();
-        return innerCommon.storeMetadata(pkg, newVersion, pkgMetadata, pkgCompositeDeps, duration);
+        return innerCommon.storeMetadata(pkg, newVersion, pkgMetadata, pkgCompositeDeps, duration, envTarget);
       })
 
 
-      // GENERATE DIFF REPORT
+      // EXPORT ADDITIONAL PIPELINE VARIABLES
       .then(() => {
-        if (branches.isMaster && pkg.remote) {
-          return innerCommon.generateDiffReport(pkg, newVersion);
-        }
+        return innerCommon.exportPipelineVariables(pkg, compositeType);
       })
 
 

package/scripts/csdr/release/package/remote.js

@@ -2,42 +2,27 @@
 
 // GLOBAL
 const path = require('path');
-
-// LOCAL
 const installUtils = require('../../install/install-utils');
-const configUtils = require('../../config/config-utils');
-const auditUtils = require('../../audit/audit-utils');
-
 
-module.exports.install = (pkg, isMaster) => {
+module.exports.install = (pkg, envTarget, compositeType) => {
   var pkgCompositeDeps = {};
 
   return Promise.resolve()
 
   // FETCHING CURRENT PACKAGES & INSTALL
   .then(() => {
-    // fetch related project if passed as arguments
-    const prj = configUtils.projects.getProject();
-
     // install the dependencies for current package build
-    return installUtils.buildPackage.install(prj, pkg, isMaster);
+    return installUtils.buildPackage.installRemote(pkg, envTarget, compositeType);
   })
   .then((compositeDeps) => {
     // save composite deps for later exports
     pkgCompositeDeps = compositeDeps;
   })
 
-
-  // AUDIT DEPENDENCIES
-  .then(() => {
-    return auditUtils.audit(pkg);
-  })
-
   .then(() => {
     return pkgCompositeDeps;
   })
 
-
   .catch((e) => {
     throw e;
   })

package/scripts/csdr/release/package/ui.js

@@ -2,14 +2,17 @@
 
 // GLOBAL
 const path = require('path');
+const glob = require('glob');
 
 // LOCAL
 const installUtils = require('../../install/install-utils');
 const configUtils = require('../../config/config-utils');
 const auditUtils = require('../../audit/audit-utils');
+const notificationUtils = require('../../../utils/notification/notification-utils');
+const tools = require('../../../utils/tools');
 
 
-module.exports.install = (pkg, isMaster) => {
+module.exports.install = (pkg) => {
   return Promise.resolve()
 
   // FETCHING CURRENT PACKAGES & INSTALL
@@ -18,13 +21,13 @@ module.exports.install = (pkg, isMaster) => {
     const prj = configUtils.projects.getProject();
 
     // install the dependencies for current package build
-    return installUtils.buildPackage.install(prj, pkg, isMaster);
+    return installUtils.buildPackage.installPackage(prj, pkg);
   })
 
 
   // CHECK INTERNAL DEPENDENCIES
   .then(() => {
-    return installUtils.buildPackage.checkDeps(pkg);
+    return checkDeps(pkg);
   })
 
 
@@ -38,3 +41,83 @@ module.exports.install = (pkg, isMaster) => {
     throw e;
   })
 }
+
+
+const checkDeps = (pkg) => {
+  tools.logTitle('Checking package internal dependencies');
+
+  return Promise.resolve()
+   .then(() => {
+     var depsFound = [];
+     var files = glob.sync('**/*.ts', { cwd: pkg.paths.pkgLibFolder, nodir: true, follow: true, dot: true });
+     files.forEach(file => {
+       const filePath = path.join(pkg.paths.pkgLibFolder, file);
+       const fileContent = tools.getFileContent(filePath);
+       var regex = /@cc\/|@mywp\/|@opsys\/|@sfc\//gi, result, indices = [];
+       while ( (result = regex.exec(fileContent)) ) {
+           indices.push(result.index);
+       }
+       if (indices.length !== 0) {
+         // tools.logInfo(`Number of occurences found : ${indices.length}`);
+         indices.forEach((i) => {
+           const endPos = fileContent.substr(i, 40).indexOf("'");
+           const dep = fileContent.substr(i, endPos);
+           if (endPos > -1) {
+             // tools.logInfo(`dep found on : ${dep}`);
+             depsFound.push(dep);
+
+           } else {
+             tools.logInfo(`Potential wrong import detected on file : ${file}`);
+             const subContent = fileContent.substr(i, 40);
+             const detectMultiSlashes = subContent.match(/\//g);
+             if (detectMultiSlashes.length > 0) {
+               tools.logError('Multislashes on import : ');
+               console.log(subContent);
+             }
+           }
+         })
+       }
+     });
+     depsFound = tools.removeArrayDuplicates(depsFound);
+     tools.logWarning(`Dependencies found : ${depsFound.length}`);
+     console.log(depsFound);
+
+     return depsFound;
+   })
+
+   .then((depsFound) => {
+     var depsLevel;
+
+     switch(true) {
+         case (depsFound.length === 1):
+           depsLevel = 'LOW (1)';
+           break;
+         case (depsFound.length > 1 && depsFound.length <= 3):
+           depsLevel = 'MEDIUM (between 1 and 3)';
+           break;
+         case (depsFound.length > 3 && depsFound.length <= 5):
+           depsLevel = 'HIGH (between 3 and 5)';
+           break;
+         case (depsFound.length > 5):
+           depsLevel = 'VERY HIGH (>5)';
+           break;
+         default:
+           depsLevel = 'NONE';
+     }
+
+     var message = `Internal dependencies detected : ${depsFound.length} - deps level: ${depsLevel}\n`;
+     message += depsFound.join('\n');
+
+
+     return notificationUtils.package.sendPackageMessage({
+      package: pkg,
+      text: message
+     });
+   })
+
+   .catch((e) => {
+     console.log(e);
+   })
+
+ }
+

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

@@ -8,6 +8,8 @@ const configUtils = require('../config/config-utils');
 
 const tools = require('../../utils/tools');
 
+const { skipPull } = tools.getArgs();
+
 module.exports.sync = () => {
   return Promise.resolve()
   .then(() => {
@@ -22,8 +24,10 @@ module.exports.sync = () => {
     tools.logSuccess();
   })
   .then(() => {
-    tools.logInfo(`Pulling root folder ...`);
-    return execa.shellSync(`git pull`, { cwd: path.join(process.cwd()), stdio: 'inherit' });
+    if (!skipPull) {
+      tools.logInfo(`Pulling root folder ...`);
+      return execa.shellSync(`git pull`, { cwd: path.join(process.cwd()), stdio: 'inherit' });
+    }
   })
   .then(() => {
     tools.logSuccess();
@@ -49,6 +53,12 @@ module.exports.sync = () => {
   .then(() => {
     return initUtils.meta.init();
   })
+  .then(() => {
+    return initUtils.processLocalEuiVersions();
+  })
+  .then(() => {
+    return initUtils.processResolutionsForNodeVersion();
+  })
   .catch((e) => {
     throw e;
   })