@eui/tools 6.14.11 → 6.14.13

package/.version.properties

@@ -1 +1 @@
-6.14.11
+6.14.13

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 6.14.13 (2023-12-09)
+
+##### Bug Fixes
+
+* **other:**
+  * package versionFirst retrieval typo in declaration - EUI-7121 [EUI-7121](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-7121)  ([67e6cbb1](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/67e6cbb1e3e7f4c88592992ccb08b1f1c225281a))
+
+* * *
+* * *
+## 6.14.12 (2023-12-09)
+
+##### Chores
+
+* **other:**
+  * fix hotfix flag for npm package version fetch - EUI-7121 [EUI-7121](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-7121)  ([a4b99eb0](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/a4b99eb0842675d5cffd3b4d4adaccb3d92e1f54))
+  * refactor metadata of UI pkg fetch and store using npm direct call - EUI-7121 [EUI-7121](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-7121)  ([942ba35e](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/942ba35e7f22e309feca6a69f9a7d6599c0c81b1))
+
+* * *
+* * *
 ## 6.14.11 (2023-12-08)
 
 ##### Chores

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@eui/tools",
-    "version": "6.14.11",
+    "version": "6.14.13",
     "tag": "latest",
     "license": "EUPL-1.1",
     "description": "eUI common tools and scripts",

package/sandbox.js

@@ -1366,18 +1366,78 @@ const publishUtils = require('./scripts/utils/publish/publish-utils');
 //     console.log(compositeDeps);
 //   })
 
-const prj = configUtils.projects.getCsdrProject('eui-showcase-ux-components');
+// const prj = configUtils.projects.getCsdrProject('eui-showcase-ux-components');
 
-Promise.resolve()
-  .then(() => {
-    return utils.buildApp.generateProjectDistributionList(prj, true);
-  })
+// Promise.resolve()
+//   .then(() => {
+//     return utils.buildApp.generateProjectDistributionList(prj, true);
+//   })
+
+//   .then((output) => {
+//     console.log(output);
+
+//     const { baseHrefIn } = tools.getArgs();
+//     const baseHref = configUtils.projects.getBaseHref(prj, '17.0.2-snapshot-1701859601406', baseHrefIn);
+
+//     console.log(baseHref);
+//   })
+
+
+// Promise.resolve()
+//   .then(() => {
+//     const pkgsIn = configUtils.packages.getCsdrPackages();
+//     let pkgs = Object.keys(pkgsIn).map(p => {
+//       return {
+//         name: p,
+//         npmPkg: pkgsIn[p].npmPkg,
+//         remote: pkgsIn[p].remote
+//       }
+//     });
+//     pkgs = pkgs.filter(p => p.npmPkg !== undefined && !p.remote && p.name.indexOf('backend') === -1);
+//     pkgs = tools.sortArray(pkgs, 'name');
+
+//     pkgs.forEach(p => {
+//       const pkg = configUtils.packages.getPackage(p.name, true);
+
+//       const lastMetadataLatest = metadataUtils.package.getPackageVersionsLastLatest(pkg);
+//       const lastMetadataSnapshot = metadataUtils.package.getPackageVersionsLastSnapshot(pkg);
+//       const lastMetadataRc = metadataUtils.package.getPackageVersionsLastRc(pkg);
+
+//       console.log(`Checking ${pkg.name}...`);
+
+//       // TODO check multi-version of LATEST f.e. : csdr-integration-ui 2.x 3.x 4.x
+
+//       try {
+//         const output = execa.sync('npm', ['view', '--latest', pkg.npmPkg, '--json']).stdout;
+//         const json = JSON.parse(output);
+//         const npmSnapshot = json['dist-tags'].snapshot;
+//         const npmLatest = json['dist-tags'].latest;
+//         const npmNext = json['dist-tags'].next;
+
+//         if (
+//           lastMetadataSnapshot !== npmSnapshot ||
+//           lastMetadataLatest !== npmLatest
+//         ) {
+//           console.log(pkg.name);
+//           console.log(lastMetadataSnapshot, lastMetadataLatest, lastMetadataRc);
+//           console.log(npmSnapshot, npmLatest, npmNext);
+//           console.log ('');
+//         }
+//       } catch(e) {
+//         console.log('---Error getting npm info for pkg');
+//       }
 
-  .then((output) => {
-    console.log(output);
+//     });
+//   })
 
-    const { baseHrefIn } = tools.getArgs();
-    const baseHref = configUtils.projects.getBaseHref(prj, '17.0.2-snapshot-1701859601406', baseHrefIn);
 
-    console.log(baseHref);
+Promise.resolve()
+  .then(() => {
+    const pkg = configUtils.packages.getPackage('cc-decidepoc-ui', true);
+    console.log(pkg);
+    const versions = metadataUtils.package.getPackageVersions(pkg);
+    console.log(JSON.stringify(versions, null, 2));
+  })
+  .catch((e) => {
+    console.log(e);
   })

package/scripts/csdr/install/common.js

@@ -16,7 +16,7 @@ const getInstallRegistry = () => {
   const NPM_REGISTRY_INSTALL = configUtils.global.getConfigOptions().NPM_REGISTRY_INSTALL;
 
   // check if registry has been passed as argument
-  var installRegistry;
+  let installRegistry;
   if (registry) {
     installRegistry = registry;
   } else {
@@ -88,7 +88,7 @@ module.exports.executeInstallPackage = (cwdPath, npmPkg) => {
 };
 
 module.exports.getResolvedCarretDeps = (deps, isMaster, isDevEnvTarget) => {
-  tools.logTitle('Resolving carret versions for prev or next version packages');
+  tools.logTitle('Resolving carret versions of detected packages');
 
   tools.logInfo('processing dependencies : ');
   console.log(deps);
@@ -101,24 +101,29 @@ module.exports.getResolvedCarretDeps = (deps, isMaster, isDevEnvTarget) => {
             const npmPkg = k;
             const version = deps[k];
 
-            tools.logInfo(`Processing ${npmPkg}:${version}`);
+            tools.logInfo(`\nProcessing ${npmPkg}:${version}`);
 
             // getting package from npmPkg
             const pkg = configUtils.packages.getPackageByNpmPkg(npmPkg, true);
 
-            // getting last major version from metadata history for pkg found
-            const lastMajorVersion = metadataUtils.package.getLastMajorVersion(
-              pkg,
-              version.substr(1).split('.')[0],
-              isMaster,
-              isDevEnvTarget
-            );
-
-            if (lastMajorVersion) {
-              tools.logInfo(`--version found : ${lastMajorVersion}`);
-              acc[k] = lastMajorVersion;
+            if (!pkg) {
+              tools.logWarning(`npmPkg: ${npmPkg} is not a CSDR package`);
+
             } else {
-              tools.logWarning(`WARNING : Can't resolve carret version from history for pkg: ${npmPkg} for version ${version}`);
+              // getting last major version from metadata history for pkg found
+              const lastMajorVersion = metadataUtils.package.getLastMajorVersion(
+                pkg,
+                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;

package/scripts/csdr/install/local-dev.js

@@ -61,9 +61,9 @@ module.exports.install = (providedDeps) => {
 
   return Promise.resolve()
 
-    .then(() => {
-      return metadataUtils.common.cloneMetadataRepo(true);
-    })
+    // .then(() => {
+    //   return metadataUtils.common.cloneMetadataRepo(true);
+    // })
 
     // getting internal packages deps - cloned locally
     .then(() => {

package/scripts/csdr/metadata/app.js

@@ -166,7 +166,6 @@ const storeMetadataAssetsStandAlone = () => {
               repository: pkgVersionMetadata.name,
               version: pkgVersionMetadata.version,
               releaseDate: pkgVersionMetadata.date,
-              buildDuration: pkgVersionMetadata.duration,
             };
           }
         });

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

@@ -37,22 +37,19 @@ module.exports.getMetadataSync = (pkg) => {
   return tools.getJsonFileContent(path.join(DEVOPS_METADATA_PATH, pkg.devopsVersionsMetadataFile));
 }
 
-module.exports.storeMetadata = (pkg, pkgVersion, pkgCompositeDeps, duration, envTarget, branches, auditStylesReport) => {
+module.exports.storeMetadata = (pkg, pkgVersion, pkgCompositeDeps, duration, envTarget) => {
   return Promise.resolve()
     .then(() => {
       tools.logInfo('Storing package version history metadata...');
 
       const configOptions = configUtils.global.getConfigOptions();
 
-      var generatedMetadata = {};
-      var versions = [];
-
-      let pkgMetadataFile;
+      let generatedMetadata = {};
+      let versions = [];
 
+      let pkgMetadataFile = path.join(configOptions.DEVOPS_METADATA_PATH, pkg.devopsVersionsMetadataFile);
       if (pkg.backend) {
         pkgMetadataFile = path.join(pkg.paths.root, 'package-versions-metadata.json');
-      } else {
-        pkgMetadataFile = path.join(configOptions.DEVOPS_METADATA_PATH, pkg.devopsVersionsMetadataFile);
       }
 
       if (tools.isFileExists(pkgMetadataFile)) {
@@ -60,11 +57,6 @@ module.exports.storeMetadata = (pkg, pkgVersion, pkgCompositeDeps, duration, env
         versions = generatedMetadata.versions;
       }
 
-      let isHotfixVersion = false;
-      if (branches) {
-        isHotfixVersion = branches.isHotfix;
-      }
-
       const newVersionMetadata = {
         name: pkg.name,
         version: pkgVersion,
@@ -72,23 +64,14 @@ module.exports.storeMetadata = (pkg, pkgVersion, pkgCompositeDeps, duration, env
         npmPkg: pkg.npmPkg,
         duration: duration,
         envTarget: envTarget,
-        hotfix: isHotfixVersion,
       };
 
-      if (auditStylesReport) {
-        if (!pkg.backend && !pkg.remote) {
-          newVersionMetadata.auditStylesReport = auditStylesReport;
-        }
-      }
-
       if (pkg.remote) {
         tools.logInfo('Writing remote composite dependencies');
         newVersionMetadata.dependencies = pkgCompositeDeps;
       }
       console.log(newVersionMetadata);
-
       versions.push(newVersionMetadata);
-
       generatedMetadata.versions = versions;
 
       tools.logInfo(`Write metadata on ${pkgMetadataFile}`);
@@ -100,7 +83,6 @@ module.exports.storeMetadata = (pkg, pkgVersion, pkgCompositeDeps, duration, env
       } else {
         tools.writeJsonFileSync(pkgMetadataFile, generatedMetadata);
       }
-
     })
 
     .catch((e) => {

package/scripts/csdr/metadata/package.js

@@ -3,6 +3,7 @@
 // GLOBAL
 const path = require('path');
 const moment = require('moment');
+const execa = require('execa');
 
 // LOCAL
 const tools = require('../../utils/tools');
@@ -14,16 +15,16 @@ const innerPackageEnvs = require('./package-envs');
 const innerPackageVersions = require('./package-versions');
 
 // FETCH ARGS
-const { dryRun } = tools.getArgs();
-
-
-module.exports.storeMetadata = (pkg, pkgVersion, pkgMetadata, branches, pkgCompositeDeps, duration, envTarget, auditStylesReport) => {
+const { dryRun, debug } = tools.getArgs();
 
+module.exports.storeMetadata = (pkg, pkgVersion, pkgMetadata, branches, pkgCompositeDeps, duration, envTarget) => {
   tools.logTitle('Storing central and package metadata...');
 
   return Promise.resolve()
     .then(() => {
-      return innerPackageVersions.storeMetadata(pkg, pkgVersion, pkgCompositeDeps, duration, envTarget, branches, auditStylesReport);
+      if (pkg.remote) {
+        return innerPackageVersions.storeMetadata(pkg, pkgVersion, pkgCompositeDeps, duration, envTarget);
+      }
     })
 
     .then(() => {
@@ -50,11 +51,8 @@ module.exports.storeMetadata = (pkg, pkgVersion, pkgMetadata, branches, pkgCompo
 
     .catch((e) => {
       throw e;
-    })
-}
-
-
-
+    });
+};
 
 const storeBuildMetadata = (pkg, pkgVersion, pkgMetadata, envTarget) => {
   return Promise.resolve()
@@ -63,8 +61,8 @@ const storeBuildMetadata = (pkg, pkgVersion, pkgMetadata, envTarget) => {
 
       const configOptions = configUtils.global.getConfigOptions();
 
-      var generatedMetadata = {};
-      var versions = [];
+      let generatedMetadata = {};
+      let versions = [];
 
       let pkgMetadataFile;
 
@@ -93,47 +91,38 @@ const storeBuildMetadata = (pkg, pkgVersion, pkgMetadata, envTarget) => {
 
     .catch((e) => {
       throw e;
-    })
-}
-
-
-
-module.exports.storeMetadataBackend = (
-  pkg, pkgVersion, pkgMetadata, isMaster, duration, envTarget
-) => {
-
-tools.logTitle('Storing Backend metadata...');
-
-return Promise.resolve()
-
-  .then(() => {
-    return innerPackageVersions.storeMetadata(pkg, pkgVersion, {}, duration, envTarget);
-  })
-
-  .then(() => {
-    if (isMaster) {
-      return storeBuildMetadata(pkg, pkgVersion, pkgMetadata, envTarget);
-    }
-  })
+    });
+};
 
-  .then(() => {
-    if (isMaster) {
-      return storePipelineMetadata(pkgMetadata);
-    }
-  })
+module.exports.storeMetadataBackend = (pkg, pkgVersion, pkgMetadata, isMaster, duration, envTarget) => {
+  tools.logTitle('Storing Backend metadata...');
 
-  .then(() => {
-    tools.logSuccess();
-  })
+  return Promise.resolve()
 
-  .catch((e) => {
-    throw e;
-  })
-}
+    .then(() => {
+      return innerPackageVersions.storeMetadata(pkg, pkgVersion, {}, duration, envTarget);
+    })
 
+    .then(() => {
+      if (isMaster) {
+        return storeBuildMetadata(pkg, pkgVersion, pkgMetadata, envTarget);
+      }
+    })
 
+    .then(() => {
+      if (isMaster) {
+        return storePipelineMetadata(pkgMetadata);
+      }
+    })
 
+    .then(() => {
+      tools.logSuccess();
+    })
 
+    .catch((e) => {
+      throw e;
+    });
+};
 
 const storePipelineMetadata = (pkgMetadata) => {
   return Promise.resolve()
@@ -142,7 +131,7 @@ const storePipelineMetadata = (pkgMetadata) => {
 
       const variablesFile = path.join(process.cwd(), 'variables');
 
-      var fileContent;
+      let fileContent;
       if (tools.isFileExists(variablesFile)) {
         fileContent = tools.getFileContent(variablesFile);
       }
@@ -156,18 +145,15 @@ const storePipelineMetadata = (pkgMetadata) => {
           fileContent += `export ISSUES_LIST=${issuesList}\n`;
           tools.writeFileContent(variablesFile, fileContent);
         }
-
       } else {
         tools.logInfo('No issues found for this release');
       }
-
     })
 
     .catch((e) => {
       console.log(e);
-    })
-}
-
+    });
+};
 
 module.exports.storeMetadataAssets = (pkg, pkgCompositeDeps) => {
   return Promise.resolve()
@@ -176,7 +162,7 @@ module.exports.storeMetadataAssets = (pkg, pkgCompositeDeps) => {
       const pkgMetadataRootFile = path.join(pkg.paths.root, 'package-metadata.json');
 
       const pkgMetadata = {
-        dependencies: pkgCompositeDeps
+        dependencies: pkgCompositeDeps,
       };
 
       tools.logInfo(`Creating ${pkgMetadataFile}`);
@@ -190,80 +176,100 @@ module.exports.storeMetadataAssets = (pkg, pkgCompositeDeps) => {
 
     .catch((e) => {
       throw e;
-    })
-}
+    });
+};
 
+const getPackageVersions = (module.exports.getPackageVersions = (pkg) => {
+  try {
+    let npmOutput = execa.sync('npm', ['view', pkg.npmPkg, '--json']).stdout;
+    if (npmOutput.trim() === '') {
+      npmOutput = execa.sync('npm', ['view', `${pkg.npmPkg}@snapshot`, '--json']).stdout;
+    }
+    const json = JSON.parse(npmOutput);
+    let versions = [];
+    versions = json.versions.map((v) => {
+      return {
+        name: pkg.name,
+        version: v,
+        major: v.split('.')[0],
+        snapshot: v.indexOf('snapshot') > -1,
+        hotfix: v.indexOf('snapshot') === -1 && v.indexOf('-rc.') === -1 && v.indexOf('-') > -1,
+        rc: v.indexOf('-rc.') > -1,
+        date: json.time[v],
+      };
+    });
 
-module.exports.getPackageVersionsJson = (pkg) => {
-  if (!pkg) {
-    tools.logWarning('provided pkg is empty...skipping');
-    return;
+    return versions;
+  } catch (e) {
+    tools.logWarning(`Pkg versions can't be fetched for ${pkg.name} - ${pkg.npmPkg}`);
+    console.log(e);
   }
+});
 
-  tools.logInfo(`Getting package versions for : ${pkg.name}...`);
-
-  const configOptions = configUtils.global.getConfigOptions();
-
-  const pkgMetadataFile = path.join(configOptions.DEVOPS_METADATA_PATH, pkg.devopsVersionsMetadataFile);
-
-  tools.logInfo(`from ${pkgMetadataFile}`);
-
-  return tools.getJsonFileContent(pkgMetadataFile);
-}
+module.exports.getPackageVersionsLatest = (pkg) => {
+  const versions = getPackageVersions(pkg);
+  return versions.filter((v) => !v.snapshot);
+};
 
+module.exports.getPackageVersionLast = (pkg) => {
+  const versions = getPackageVersions(pkg);
+  if (versions && versions.length !== 0) {
+    return versions.splice(-1)[0].version;
+  }
+};
 
-module.exports.getPackageVersions = (pkg) => {
-  const pkgVersionsJson = this.getPackageVersionsJson(pkg);
+module.exports.getPackageVersionsLastLatest = (pkg) => {
+  const versions = getPackageVersions(pkg);
 
-  if (pkgVersionsJson) {
-    return pkgVersionsJson.versions;
+  if (versions && versions.length !== 0) {
+    const versionsLatest = versions.filter((v) => !v.snapshot && !v.hotfix && !v.rc);
+    if (versionsLatest && versionsLatest.length !== 0) {
+      return versionsLatest.splice(-1)[0].version;
+    }
   }
-}
+};
 
-module.exports.getPackageVersionsLatest = (pkg) => {
-  const pkgVersionsJson = this.getPackageVersionsJson(pkg);
+module.exports.getPackageVersionsLastRc = (pkg) => {
+  const versions = this.getPackageVersions(pkg);
 
-  if (pkgVersionsJson && pkgVersionsJson.versions) {
-    return pkgVersionsJson.versions.filter((v) => {
-      return v.version.indexOf('snapshot') === -1;
-    });
+  if (versions && versions.length !== 0) {
+    const versionsRc = versions.filter((v) => v.rc);
+    if (versionsRc && versionsRc.length !== 0) {
+      return versionsRc.splice(-1)[0].version;
+    }
   }
+};
 
-  return;
-}
+const getPackageVersionsSnapshot = (pkg) => {
+  const versions = getPackageVersions(pkg);
+  return versions.filter((v) => v.snapshot);
+};
 
-module.exports.getPackageVersionLast = (pkg) => {
-  const pkgVersionsJson = this.getPackageVersionsJson(pkg);
-
-  if (pkgVersionsJson && pkgVersionsJson.versions) {
-    return pkgVersionsJson.versions.splice(-1)[0].version;
+module.exports.getPackageVersionsLastSnapshot = (pkg) => {
+  const versions = getPackageVersionsSnapshot(pkg);
+  if (versions && versions.length !== 0) {
+    return versions.splice(-1)[0].version;
   }
+};
 
-  return;
-}
-
-module.exports.getPackageVersionFirst = (pkg) => {
-  const pkgVersionsJson = this.getPackageVersionsJson(pkg);
+const getPackageVersionFirst = (pkg) => {
+  const versions = getPackageVersions(pkg);
 
-  if (pkgVersionsJson && pkgVersionsJson.versions) {
-    return pkgVersionsJson.versions[0];
+  if (versions && versions.length !== 0) {
+    return versions[0];
   }
-
-  return;
-}
+};
 
 module.exports.isNewPackageBuild = (pkg) => {
   tools.logInfo('Checking if package is a newly created one : first build date after 2023/06/01 or never built for MASTER');
 
-  const firstPackageVersion = this.getPackageVersionFirst(pkg);
+  const firstPackageVersion = getPackageVersionFirst(pkg);
   const versionsLatest = this.getPackageVersionsLatest(pkg);
 
   if (firstPackageVersion) {
-
     if (versionsLatest && versionsLatest.length === 0) {
       tools.logInfo(`==> package has never been built for MASTER / latest version, package is considered new`);
       return true;
-
     } else {
       const pkgDate = firstPackageVersion.date;
 
@@ -273,104 +279,100 @@ module.exports.isNewPackageBuild = (pkg) => {
       tools.logInfo(`==> NEW package : ${pkgDateM > pivotDate}`);
       return pkgDateM > pivotDate;
     }
-
   } else {
     tools.logInfo(`==> no versions metadata found : first build, package is new`);
     return true;
   }
-}
+};
 
-module.exports.getPackageVersionsByMajor = (pkg, major, isMaster, isDevEnvTarget) => {
-  const pkgVersions = this.getPackageVersions(pkg);
+const getPackageVersionsByMajor = (pkg, major, isMaster, isDevEnvTarget) => {
+  const pkgVersions = getPackageVersions(pkg);
 
   if (pkgVersions) {
-    tools.logInfo(`----> ${pkgVersions.length} metadata versions found for package`);
+    if (debug) tools.logInfo(`----> ${pkgVersions.length} metadata versions found for package`);
     let versions = [];
-    versions = pkgVersions.filter(v => v.version.split('.')[0] === major);
+    versions = pkgVersions.filter((v) => v.major === major);
 
-    tools.logInfo(`----> ${versions.length} metadata versions found for major version : ${major}`);
+    if (debug) tools.logInfo(`----> ${versions.length} metadata versions found for major version : ${major}`);
 
     if (isMaster) {
-      versions = versions.filter(v => v.version.indexOf('snapshot') === -1);
-      tools.logInfo(`----> ${versions.length} metadata versions found excluding snapshots`);
-
+      versions = versions.filter((v) => !v.snapshot);
+      if (debug) tools.logInfo(`----> ${versions.length} metadata versions found excluding snapshots`);
     } else {
-      versions = pkgVersions.filter(v => v.version.split('.')[0] === major);
-      tools.logInfo(`----> ${versions.length} metadata versions non-master release for major`);
+      versions = pkgVersions.filter((v) => v.major === major);
+      if (debug) tools.logInfo(`----> ${versions.length} metadata versions non-master release for major`);
     }
 
-    tools.logInfo('----> exluding hotfix package versions type');
-    versions = versions.filter(v => !v.hotfix);
-    tools.logInfo(`----> ${versions.length} metadata versions excluding hotfix version type`);
+    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) {
-      tools.logInfo('----=> excludingi RC release of versions found for non-DEV build (preventing RC releases to go to another env than DEV');
-      versions = versions.filter(v => v.version.indexOf('-rc.') === -1);
-      tools.logInfo(`----> ${versions.length} metadata versions excluding hotfix version type`);
+      if (debug) {
+        tools.logInfo(
+          '----=> excludingi 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 hotfix version type`);
     }
 
     return versions;
   }
-}
+};
 
 module.exports.getLastMajorVersion = (pkg, major, isMaster, isDevEnvTarget) => {
-  const pkgVersionsMajor = this.getPackageVersionsByMajor(pkg, major, isMaster, isDevEnvTarget);
+  tools.logInfo(`--Getting registry pkg version for ${pkg.name} - major: ${major}`);
+
+  const pkgVersionsMajor = getPackageVersionsByMajor(pkg, major, isMaster, isDevEnvTarget);
 
   if (pkgVersionsMajor && pkgVersionsMajor.length !== 0) {
     return pkgVersionsMajor.splice(-1)[0].version;
   }
-}
+};
 
 module.exports.getVersionMetadata = (pkg, version) => {
-  const pkgVersions = this.getPackageVersions(pkg);
+  const pkgVersions = getPackageVersions(pkg);
   if (pkgVersions) {
     return pkgVersions.filter((v) => {
-      return v.version === version
+      return v.version === version;
     })[0];
-
   } else {
     tools.logWarning('no package metadata found for ' + pkg.name);
   }
-}
+};
 
 module.exports.lockPackage = (pkg) => {
   tools.logTitle('Locking package');
 
   return Promise.resolve()
     .then(() => {
-
       const configOptions = configUtils.global.getConfigOptions();
       const pkgLockFile = path.join(configOptions.DEVOPS_METADATA_LOCKS_PATH, `${pkg.name}-lock.json`);
 
       const lockContent = {
         locked: true,
         lockedDate: moment().format(),
-      }
+      };
 
       tools.writeJsonFileSync(pkgLockFile, lockContent);
 
       if (!dryRun) {
         tools.logTitle('Commiting metadata info');
-        return gitUtils.commitAndPush(
-          'master',
-          `chore: locking ${pkg.name}`,
-          configOptions.DEVOPS_METADATA_LOCKS_PATH
-        );
+        return gitUtils.commitAndPush('master', `chore: locking ${pkg.name}`, configOptions.DEVOPS_METADATA_LOCKS_PATH);
       }
     })
 
     .catch((e) => {
       throw e;
-    })
-}
-
+    });
+};
 
 module.exports.unlockPackage = (pkg) => {
   tools.logTitle('Unlocking package');
 
   return Promise.resolve()
     .then(() => {
-
       const configOptions = configUtils.global.getConfigOptions();
       const pkgLockFile = path.join(configOptions.DEVOPS_METADATA_LOCKS_PATH, `${pkg.name}-lock.json`);
 
@@ -378,19 +380,14 @@ module.exports.unlockPackage = (pkg) => {
 
       if (!dryRun) {
         tools.logTitle('Commiting metadata info');
-        return gitUtils.commitAndPush(
-          'master',
-          `chore: unlocking ${pkg.name}`,
-          configOptions.DEVOPS_METADATA_LOCKS_PATH
-        );
+        return gitUtils.commitAndPush('master', `chore: unlocking ${pkg.name}`, configOptions.DEVOPS_METADATA_LOCKS_PATH);
       }
     })
 
     .catch((e) => {
       tools.logError('Unable to unlock package => package will be auto-unlock at next build 10m after the current one');
-    })
-}
-
+    });
+};
 
 module.exports.isPackageLocked = (pkg) => {
   const configOptions = configUtils.global.getConfigOptions();
@@ -416,17 +413,13 @@ module.exports.isPackageLocked = (pkg) => {
           tools.logInfo(`< 10m => keep lock`);
           return true;
         }
-
       } else {
         return false;
       }
-
-    } catch(e) {
+    } catch (e) {
       return false;
     }
   }
 
   return false;
-}
-
-
+};

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

@@ -516,7 +516,7 @@ module.exports.runGitOperations = (pkg, version) => {
 
 
 
-module.exports.storeMetadata = (pkg, version, pkgMetadata, pkgCompositeDeps, duration, envTarget, auditStylesReport) => {
+module.exports.storeMetadata = (pkg, version, pkgMetadata, pkgCompositeDeps, duration, envTarget) => {
   utils.tools.logBanner('STORE METADATA');
 
   const branches = this.getBranches();
@@ -529,7 +529,6 @@ module.exports.storeMetadata = (pkg, version, pkgMetadata, pkgCompositeDeps, dur
       pkgCompositeDeps,
       duration,
       envTarget,
-      auditStylesReport,
     );
   })
 
@@ -630,32 +629,30 @@ module.exports.exportPipelineVariables = (pkg, compositeType) => {
 
   return Promise.resolve()
   .then(() => {
-    if (pkg.remote) {
-      utils.tools.logTitle('Exporting pkg remote variables');
+    utils.tools.logTitle('Exporting pkg remote variables');
 
-      utils.tools.logInfo('Exporting APP_TARGET');
+    utils.tools.logInfo('Exporting APP_TARGET');
 
-      let appTarget = 'MWP_ONLY';
+    let appTarget = 'MWP_ONLY';
 
-      if (pkg.build && pkg.build.appTarget) {
-        appTarget = pkg.build.appTarget;
-      }
+    if (pkg.build && pkg.build.appTarget) {
+      appTarget = pkg.build.appTarget;
+    }
 
-      utils.tools.logInfo(`appTarget generated : ${appTarget}`);
+    utils.tools.logInfo(`appTarget generated : ${appTarget}`);
 
-      variablesContent += `export APP_TARGET=${appTarget}\n`;
+    variablesContent += `export APP_TARGET=${appTarget}\n`;
 
-      if (compositeType) {
-        utils.tools.logInfo(`Exporting COMPOSITE_TYPE : ${compositeType}`);
-        variablesContent += `export COMPOSITE_TYPE=${compositeType}\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(process.cwd(), variablesContent);
-      }
+    if (dryRun) {
+      utils.tools.logWarning('dryRun...skipping export');
+    } else {
+      utils.tools.logInfo('Exporting appTarget variable');
+      return utils.pipeline.setVariables(process.cwd(), variablesContent);
     }
   })
 

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

@@ -132,12 +132,6 @@ module.exports.run = () => {
         return innerCommon.runGitOperations(pkg, newVersion);
       })
 
-
-      // EXPORT ADDITIONAL PIPELINE VARIABLES
-      .then(() => {
-        return innerCommon.exportPipelineVariables(pkg, compositeType);
-      })
-
       // SEND SUCCESS NOTIFICATION
       .then(() => {
         return innerCommon.sendSuccessNotification(pkg, newVersion, pkgMetadata)

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

@@ -183,7 +183,9 @@ module.exports.run = () => {
       .then(() => {
         // get run duration
         const duration = utils.pipeline.getTimerDuration();
-        return innerCommon.storeMetadata(pkg, newVersion, pkgMetadata, pkgCompositeDeps, duration, envTarget, auditStylesReport);
+        if (branches.isMaster || pkg.remote ) {
+          return innerCommon.storeMetadata(pkg, newVersion, pkgMetadata, pkgCompositeDeps, duration, envTarget);
+        }
       })
 
       // STORING PACKAGE HISTORY
@@ -195,12 +197,16 @@ module.exports.run = () => {
 
       // COMMITING METADATA
       .then(() => {
-        return innerCommon.commitMetadata(pkg, newVersion);
+        if (branches.isMaster || pkg.remote ) {
+          return innerCommon.commitMetadata(pkg, newVersion);
+        }
       })
 
       // EXPORT ADDITIONAL PIPELINE VARIABLES
       .then(() => {
-        return innerCommon.exportPipelineVariables(pkg, compositeType);
+        if (pkg.remote) {
+          return innerCommon.exportPipelineVariables(pkg, compositeType);
+        }
       })
 
       // SEND SUCCESS NOTIFICATION

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

@@ -133,7 +133,9 @@ module.exports.run = () => {
 
       // EXPORT ADDITIONAL PIPELINE VARIABLES
       .then(() => {
-        return innerCommon.exportPipelineVariables(pkg, compositeType);
+        if (pkg.remote) {
+          return innerCommon.exportPipelineVariables(pkg, compositeType);
+        }
       })
 
       // SEND SUCCESS NOTIFICATION