@eui/tools 6.14.10 → 6.14.12

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 version[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