@eui/tools 6.19.3 → 6.20.1

package/scripts/csdr/install/common.js

@@ -72,14 +72,75 @@ module.exports.installDeps = (deps) => {
   );
 };
 
-const executeInstall = (module.exports.executeInstall = (cwdPath) => {
+
+module.exports.installDepsStandalone = (pkg, deps) => {
+  const rootFolder = process.cwd();
+  const pkgJsonFile = path.resolve(rootFolder, 'package.json');
+  const pkgJson = require(pkgJsonFile);
+
+  return (
+    Promise.resolve()
+      // parse eUI deps and explode the sub-packages (v17 issues)
+      .then(() => {
+        const euiVersion = configUtils.packages.getPackageEuiVersion(pkg);
+        const euiVersionNumber = parseInt(euiVersion);
+
+        if (euiVersionNumber >= 17) {
+          Object.keys(deps).forEach((dep) => {
+            if (dep === '@eui/deps-base') {
+              deps['@eui/components'] = deps[dep];
+              deps['@eui/showcase'] = deps[dep];
+              deps['@eui/styles'] = deps[dep];
+            }
+          });
+        }
+      })
+
+      // Install dependencies
+      .then(() => {
+        tools.logTitle('Package dependencies to install : ');
+        pkgJson.dependencies = deps;
+
+        // Updating file and installing
+        if (Object.keys(pkgJson.dependencies).length !== 0) {
+          tools.writeJsonFileSync(pkgJsonFile, pkgJson);
+          tools.logInfo('installing dependencies');
+          console.log(pkgJson.dependencies);
+
+          return executeInstall(rootFolder, configUtils.global.getConfigOptionsStandalone().NPM_REGISTRY_INSTALL);
+        }
+      })
+
+      .then(() => {
+        pkgJson.dependencies = {}
+        pkgJson.resolutions = {}
+        tools.writeJsonFileSync(pkgJsonFile, pkgJson);
+      })
+
+      .catch((e) => {
+        throw e;
+      })
+  );
+};
+
+
+
+const executeInstall = (module.exports.executeInstall = (cwdPath, npmRegistry) => {
   return Promise.resolve()
     .then(() => {
-      const installRegistry = getInstallRegistry();
+      let installRegistry;
+
+      if (npmRegistry) {
+        installRegistry = npmRegistry;
+      } else {
+        installRegistry = getInstallRegistry();
+      }
 
       tools.logInfo(`Install from : ${installRegistry}`);
       if (!dryRun && !skipInstall) {
         return execa.shellSync(`yarn --registry ${installRegistry}`, { cwd: cwdPath, stdio: 'inherit' });
+      } else {
+        tools.logInfo(`Skipping install - Executing command : yarn --registry ${installRegistry}`);
       }
     })
 
@@ -157,3 +218,50 @@ module.exports.getResolvedCarretDeps = (deps, isMaster, isDevEnvTarget) => {
       })
   );
 };
+
+
+module.exports.getResolvedCarretDepsStandalone = (deps, isMaster, isDevEnvTarget) => {
+  tools.logTitle('Resolving carret versions of detected packages');
+
+  tools.logInfo('processing dependencies : ');
+  console.log(deps);
+
+  return (
+    Promise.resolve()
+      .then(() => {
+        const dependencies = Object.keys(deps).reduce((acc, k) => {
+          if (deps[k] && deps[k].substr(0, 1) === '^') {
+            const npmPkg = k;
+            const version = deps[k];
+
+            tools.logInfo(`\nProcessing ${npmPkg}:${version}`);
+
+            // getting last major version from metadata history for pkg found
+            const lastMajorVersion = metadataUtils.packageUtils.getLastMajorVersionByNpmPkg(
+              npmPkg,
+              version.substr(1).split('.')[0],
+              isMaster,
+              isDevEnvTarget
+            );
+
+            if (lastMajorVersion) {
+              tools.logInfo(`--version found : ${lastMajorVersion}`);
+              acc[k] = lastMajorVersion;
+            } else {
+              tools.logWarning(`WARNING : Can't resolve carret version from history for pkg: ${npmPkg} for version ${version}`);
+            }
+          }
+          return acc;
+        }, {});
+
+        return { ...deps, ...dependencies };
+      })
+
+      // don't rethrow in case of error, just log the exception
+      .catch((e) => {
+        tools.logError('Unable to resolve deps');
+        console.log(e);
+        return deps;
+      })
+  );
+};

package/scripts/csdr/install/packages.js

@@ -72,10 +72,15 @@ const getLocalPackageCompositeDeps = (pkg) => {
   let pkgJsonFile;
 
   if (!skipLocalPackagesDeps) {
-    if (pkg.child) {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'dependencies-composite.json');
+
+    if (pkg.standalone) {
+      pkgJsonFile = path.join(process.cwd(), 'dependencies-composite.json');
     } else {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'dependencies-composite.json');
+      if (pkg.child) {
+        pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'dependencies-composite.json');
+      } else {
+        pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'dependencies-composite.json');
+      }
     }
 
     if (tools.isFileExists(pkgJsonFile)) {
@@ -122,10 +127,14 @@ const getLocalPackageBaseDeps = (pkg) => {
   let pkgJsonFile;
 
   if (!skipLocalPackagesDeps) {
-    if (pkg.child) {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'dependencies-base.json');
+    if (pkg.standalone) {
+      pkgJsonFile = path.join(process.cwd(), 'dependencies-base.json');
     } else {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'dependencies-base.json');
+      if (pkg.child) {
+        pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'dependencies-base.json');
+      } else {
+        pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'dependencies-base.json');
+      }
     }
 
     if (tools.isFileExists(pkgJsonFile)) {
@@ -277,3 +286,47 @@ module.exports.installDeps = (prj, pkg, isMaster) => {
       throw e;
     })
 }
+
+
+module.exports.installDepsStandalone = (pkg, isMaster) => {
+  let localPkgDeps, localPkgCompositeDeps, remappedDeps, localPkgBaseDeps;
+
+  return Promise.resolve()
+    // fetching depedencies composite deps
+    .then(() => {
+      return getLocalPackageCompositeDeps(pkg);
+    })
+    // storing
+    .then((localPkgCompositeDepsIn) => {
+      localPkgCompositeDeps = localPkgCompositeDepsIn;
+    })
+
+    // remapping from registry
+    .then(() => {
+      return innerCommon.getResolvedCarretDepsStandalone(localPkgCompositeDeps, isMaster, !isMaster);
+    })
+    // storing
+    .then((remappedDepsIn) => {
+      remappedDeps = remappedDepsIn;
+    })
+
+    // fetch dependencies-base deps
+    .then(() => {
+      return getLocalPackageBaseDeps(pkg);
+    })
+
+    .then((localPkgBaseDepsIn) => {
+      localPkgBaseDeps = localPkgBaseDepsIn;
+
+      const fixedDeps = configUtils.global.getConfigOptionsStandalone().NPM_FIXED_DEPENDENCIES;
+
+      return innerCommon.installDepsStandalone(pkg, { ...localPkgBaseDeps, ...remappedDeps, ...localPkgDeps, ...fixedDeps});
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+

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

@@ -63,6 +63,55 @@ const getPackageVersions = (module.exports.getPackageVersions = (pkg) => {
   return versions;
 });
 
+
+const getPackageVersionsByNpmPkg = (module.exports.getPackageVersionsByNpmPkg = (npmPkg) => {
+  let npmOutput;
+  try {
+    npmOutput = execa.sync('npm', ['view', npmPkg, '--json']).stdout;
+    if (npmOutput.trim() === '') {
+      npmOutput = execa.sync('npm', ['view', `${npmPkg}@snapshot`, '--json']).stdout;
+    }
+  } catch(e) {
+    npmOutput = e.stdout;
+  }
+  // console.log(npmOutput);
+
+  let versions = [];
+
+  if (!npmOutput) {
+    tools.logWarning('Cannot find version of pkg - package is probably not published yet');
+    return versions;
+  }
+
+  const json = JSON.parse(npmOutput);
+
+  if (json.error) {
+    tools.logWarning('Error detected while trying to fetch the pkg version');
+    console.log(json.error);
+
+  } else {
+    if (json.versions) {
+      versions = json.versions.map((v) => {
+        return {
+          name: npmPkg,
+          version: v,
+          major: v.split('.')[0],
+          snapshot: v.indexOf('snapshot') > -1,
+          hotfix: v.indexOf('snapshot') === -1 && v.indexOf('-rc.') === -1 && v.indexOf('-next.') === -1 && v.indexOf('-') > -1,
+          rc: v.indexOf('-rc.') > -1,
+          date: json.time[v],
+        };
+      });
+    }
+  }
+
+  if (versions.length === 0) {
+    tools.logWarning(`Pkg versions not found for ${npmPkg}`);
+  }
+
+  return versions;
+});
+
 module.exports.getPackageVersionsLatest = (pkg) => {
   const versions = getPackageVersions(pkg);
   return versions.filter((v) => !v.snapshot);
@@ -142,39 +191,55 @@ module.exports.isNewPackageBuild = (pkg) => {
   }
 };
 
-const getPackageVersionsByMajor = (pkg, major, isMaster, isDevEnvTarget) => {
-  const pkgVersions = getPackageVersions(pkg);
 
-  if (pkgVersions) {
-    if (debug) tools.logInfo(`----> ${pkgVersions.length} metadata versions found for package`);
-    let versions = [];
+
+const filterMajorVersions = (pkgVersions, major, isMaster, isDevEnvTarget) => {
+  if (debug) tools.logInfo(`----> ${pkgVersions.length} metadata versions found for package`);
+
+  let versions = [];
+  versions = pkgVersions.filter((v) => v.major === major);
+
+  if (debug) tools.logInfo(`----> ${versions.length} metadata versions found for major version : ${major}`);
+
+  if (isMaster) {
+    versions = versions.filter((v) => !v.snapshot);
+    if (debug) tools.logInfo(`----> ${versions.length} metadata versions found excluding snapshots`);
+  } else {
     versions = pkgVersions.filter((v) => v.major === major);
+    if (debug) tools.logInfo(`----> ${versions.length} metadata versions non-master release for major`);
+  }
 
-    if (debug) tools.logInfo(`----> ${versions.length} metadata versions found for major version : ${major}`);
+  if (debug) tools.logInfo('----> exluding hotfix package versions type');
+  versions = versions.filter((v) => !v.hotfix);
+  if (debug) tools.logInfo(`----> ${versions.length} metadata versions excluding hotfix version type`);
 
-    if (isMaster) {
-      versions = versions.filter((v) => !v.snapshot);
-      if (debug) tools.logInfo(`----> ${versions.length} metadata versions found excluding snapshots`);
-    } else {
-      versions = pkgVersions.filter((v) => v.major === major);
-      if (debug) tools.logInfo(`----> ${versions.length} metadata versions non-master release for major`);
+  if (!isDevEnvTarget) {
+    if (debug) {
+      tools.logInfo(
+        '----=> excluding RC release of versions found for non-DEV build (preventing RC releases to go to another env than DEV'
+      );
     }
+    versions = versions.filter((v) => !v.rc);
+    if (debug) tools.logInfo(`----> ${versions.length} metadata versions excluding RC version type`);
+  }
+
+  return versions;
+}
 
-    if (debug) tools.logInfo('----> exluding hotfix package versions type');
-    versions = versions.filter((v) => !v.hotfix);
-    if (debug) tools.logInfo(`----> ${versions.length} metadata versions excluding hotfix version type`);
 
-    if (!isDevEnvTarget) {
-      if (debug) {
-        tools.logInfo(
-          '----=> excluding RC release of versions found for non-DEV build (preventing RC releases to go to another env than DEV'
-        );
-      }
-      versions = versions.filter((v) => !v.rc);
-      if (debug) tools.logInfo(`----> ${versions.length} metadata versions excluding RC version type`);
-    }
+const getPackageVersionsByMajor = (pkg, major, isMaster, isDevEnvTarget) => {
+  const pkgVersions = getPackageVersions(pkg);
 
-    return versions;
+  if (pkgVersions) {
+    return filterMajorVersions(pkgVersions, major, isMaster, isDevEnvTarget);
+  }
+};
+
+const getPackageVersionsByMajorByNpmPkg = (npmPkg, major, isMaster, isDevEnvTarget) => {
+  const pkgVersions = getPackageVersionsByNpmPkg(npmPkg);
+
+  if (pkgVersions) {
+    return filterMajorVersions(pkgVersions, major, isMaster, isDevEnvTarget);
   }
 };
 
@@ -188,6 +253,16 @@ module.exports.getLastMajorVersion = (pkg, major, isMaster, isDevEnvTarget) => {
   }
 };
 
+module.exports.getLastMajorVersionByNpmPkg = (npmPkg, major, isMaster, isDevEnvTarget) => {
+  tools.logInfo(`--Getting registry pkg version for ${npmPkg} - major: ${major}`);
+
+  const pkgVersionsMajor = getPackageVersionsByMajorByNpmPkg(npmPkg, major, isMaster, isDevEnvTarget);
+
+  if (pkgVersionsMajor && pkgVersionsMajor.length !== 0) {
+    return pkgVersionsMajor.splice(-1)[0].version;
+  }
+};
+
 module.exports.getVersionMetadata = (pkg, version) => {
   const pkgVersions = getPackageVersions(pkg);
   if (pkgVersions) {

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

@@ -12,13 +12,9 @@ const versionUtils = require('../../version/version-utils');
 const configUtils = require('../../config/config-utils');
 
 // GLOBAL ARGS
-const { dryRun, pipelineId } = utils.tools.getArgs();
-
-
-
-const getBranches = module.exports.getBranches = () => {
-  let { branch } = utils.tools.getArgs();
+const { dryRun, pipelineId, skipCommitsCheck } = utils.tools.getArgs();
 
+const getBranchDefs = (branch) => {
   if (!branch) {
     branch = 'master';
   }
@@ -48,6 +44,22 @@ const getBranches = module.exports.getBranches = () => {
   }
 }
 
+const getBranches = module.exports.getBranches = () => {
+  let { branch } = utils.tools.getArgs();
+
+  return getBranchDefs(branch);
+}
+
+const getBranchesFromRepo = module.exports.getBranchesFromRepo = () => {
+  let branch = utils.git.getBranchName();
+
+  return getBranchDefs(branch);
+}
+
+
+
+
+
 module.exports.getEnvTarget = () => {
   let { envTarget } = utils.tools.getArgs();
 
@@ -93,51 +105,61 @@ module.exports.init = (pkg, envTarget) => {
     }
   }
 
+  return Promise.resolve()
+    .then(() => {
+      return initMessage(pkg, branches, envTarget);
+    })
 
+    .catch((e) => {
+      throw e;
+    })
+}
 
+
+const initMessage = module.exports.initMessage = (pkg, branches, envTarget) => {
   return Promise.resolve()
 
-    // Starting the release flow
-    .then(() => {
-      // initiating mail buffer
-      utils.notification.messageStack.startStack();
+  // Starting the release flow
+  .then(() => {
+    // initiating mail buffer
+    utils.notification.messageStack.startStack();
 
-      // run start
-      console.log('\n\n');
-      utils.tools.logTitle('-------------------------------------------------------------------------------');
-      utils.tools.logTitle(`Releasing new version of package "${pkg.name}" on branch "${branches.branch}"`);
-      utils.tools.logTitle('-------------------------------------------------------------------------------');
+    // run start
+    console.log('\n\n');
+    utils.tools.logTitle('-------------------------------------------------------------------------------');
+    utils.tools.logTitle(`Releasing new version of package "${pkg.name}" on branch "${branches.branch}"`);
+    utils.tools.logTitle('-------------------------------------------------------------------------------');
 
-      console.log(pkg);
+    console.log(pkg);
 
-      let launchMessage = ':arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward:';
+    let launchMessage = ':arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward: :arrow_forward:';
 
-      if (pkg.remote) {
-        launchMessage += ` Launching remote *${pkg.name}* release for ENV: *${envTarget}*`;
-      } else {
-        launchMessage += ` Launching *${pkg.name}* release for branch *${branches.branch}*`;
-      }
+    if (pkg.remote) {
+      launchMessage += ` Launching remote *${pkg.name}* release for ENV: *${envTarget}*`;
+    } else {
+      launchMessage += ` Launching *${pkg.name}* release for branch *${branches.branch}*`;
+    }
+
+    return utils.notification.package.sendPackageMessage({
+      package: pkg,
+      text: launchMessage
+    });
+  })
+
+  .then(() => {
+    if (pipelineId) {
+      const launchMessage = `:arrow_forward: :arrow_forward: Pipeline ID : https://gitlab.ecdevops.eu/eui/cc-csdr-root/-/pipelines/${pipelineId}`;
 
       return utils.notification.package.sendPackageMessage({
         package: pkg,
         text: launchMessage
       });
-    })
-
-    .then(() => {
-      if (pipelineId) {
-        const launchMessage = `:arrow_forward: :arrow_forward: Pipeline ID : https://gitlab.ecdevops.eu/eui/cc-csdr-root/-/pipelines/${pipelineId}`;
-
-        return utils.notification.package.sendPackageMessage({
-          package: pkg,
-          text: launchMessage
-        });
-      }
-    })
+    }
+  })
 
-    .catch((e) => {
-      throw e;
-    })
+  .catch((e) => {
+    throw e;
+  })
 }
 
 
@@ -183,6 +205,20 @@ module.exports.cloneMetadataLocksRepos = (pkg) => {
 }
 
 
+const checkBranchValidity = module.exports.checkBranchValidity = (branches) => {
+  utils.tools.logTitle('Checking branch validity');
+
+  if (!branches.valid) {
+    utils.tools.logInfo('Branch not supported ... stopping : allowed branches are develop-master-next/-support/-hotfix/');
+    throw new Error('BRANCH_NOT_SUPPORTED');
+
+  } else {
+    utils.tools.logInfo('Branch is valid... processing');
+  }
+}
+
+
+
 module.exports.preReleaseChecks = (pkg) => {
   if (dryRun) {
     return;
@@ -202,15 +238,7 @@ module.exports.preReleaseChecks = (pkg) => {
   .then(() => {
     const branches = this.getBranches();
 
-    utils.tools.logTitle('Checking branch validity');
-
-    if (!branches.valid) {
-      utils.tools.logInfo('Branch not supported ... stopping : allowed branches are develop-master-next/-support/-hotfix/');
-      throw new Error('BRANCH_NOT_SUPPORTED');
-
-    } else {
-      utils.tools.logInfo('Branch is valid... processing');
-    }
+    checkBranchValidity(branches);
   })
 
   // CHECK eUI VERSION OF PKG VALIDITY (no v10 allowed after 5/04)
@@ -259,6 +287,11 @@ module.exports.commitMetadataChecks = (pkg) => {
   utils.tools.logTitle('Checking package commit metadata');
   let pkgMetadata;
 
+  if (skipCommitsCheck) {
+    utils.tools.logInfo('Commits checks skip active...skippping');
+    return {};
+  }
+
   if (pkg.remote) {
     utils.tools.logWarning('Remote package...skipping');
     return {};
@@ -309,7 +342,13 @@ module.exports.updateVersion = (pkg, pkgMetadata, envTarget) => {
   utils.tools.logBanner('UPDATE VERSION');
 
   // getting branch flags
-  const branches = this.getBranches();
+  let branches;
+
+  if (pkg.standalone) {
+    branches = this.getBranchesFromRepo();
+  } else {
+    branches = this.getBranches();
+  }
 
   // local vars
   let newVersion;
@@ -442,7 +481,7 @@ const commitPackage = (pkg, version, branches) => {
   .then(() => {
     return utils.git.commitAndPush(
       branches.branch,
-      `chore(release): update version: ${version} - from CI server`,
+      `chore(release): update version: ${version} - from CI server [skip ci]`,
       pkg.paths.root
     );
   })
@@ -459,7 +498,7 @@ const tagAndMerge = (pkg, version, branches) => {
     if (!branches.isSnapshot && !branches.isSupportSnapshot) {
       return utils.git.tagVersion(
         version, branches.branch,
-        `chore(release): tagging ${version} - from CI server`,
+        `chore(release): tagging ${version} - from CI server [skip ci]`,
         pkg.paths.root
       );
     }
@@ -491,7 +530,12 @@ const tagAndMerge = (pkg, version, branches) => {
 module.exports.runGitOperations = (pkg, version) => {
   utils.tools.logBanner('RUN GIT OPERATIONS');
 
-  const branches = this.getBranches();
+  let branches;
+  if (pkg.standalone) {
+    branches = this.getBranchesFromRepo();
+  } else {
+    branches = this.getBranches();
+  }
   console.log(branches);
 
   if (pkg.remote && pkg.build && pkg.build.envTargetActive) {
@@ -618,7 +662,7 @@ module.exports.sendSuccessNotification = (pkg, version, pkgMetadata) => {
       if (!pkg.backend) {
         return Promise.resolve()
         .then(() => {
-          if (pkg.build && pkg.build.skipLock) {
+          if ((pkg.build && pkg.build.skipLock) || pkg.standalone) {
             utils.tools.logInfo('lock package de-activated...skipping');
           } else {
             return metadataUtils.packageUtils.unlockPackage(pkg);
@@ -661,7 +705,7 @@ module.exports.sendErrorNotification = (pkg, exception, pkgMetadata) => {
         if (exception !== 'PACKAGE_LOCKED') {
           return Promise.resolve()
           .then(() => {
-            if (pkg.build && pkg.build.skipLock) {
+            if ((pkg.build && pkg.build.skipLock) || pkg.standalone) {
               utils.tools.logInfo('lock package de-activated...skipping');
             } else {
               return metadataUtils.packageUtils.unlockPackage(pkg);

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

@@ -0,0 +1,24 @@
+'use strict';
+
+// UTILS
+const tools = require('../../../utils/tools');
+const configUtils = require('../../config/config-utils');
+
+// INNER MODULES
+const innerReleaseUiStandalone = require('./release-ui-standalone');
+
+
+module.exports.run = () => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logVersion();
+    })
+
+    .then(() => {
+      return innerReleaseUiStandalone.run();
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}