@eui/tools 6.19.2 → 6.20.0

package/scripts/csdr/config/angular.js

@@ -38,6 +38,7 @@ const {
   angularPackageDefV13,
   angularPackageDefV14,
   angularPackageDefV15,
+  angularPackageDefV15Standalone,
   angularElementProjectDef,
   tsConfigDef,
   tsConfigSpecDef,
@@ -75,6 +76,14 @@ module.exports.checkConfigFiles = (isReset) => {
   }
 }
 
+module.exports.checkAngularConfig = () => {
+  const angularConfig = path.join(process.cwd(), 'angular.json');
+
+  if (!tools.isFileExists(angularConfig)) {
+    tools.logInfo('Creating angular.json');
+    tools.writeJsonFileSync(angularConfig, angularConfigDef);
+  }
+}
 
 module.exports.registerAngularPackage = (pkg, isReset) => {
 
@@ -98,7 +107,11 @@ module.exports.registerAngularPackage = (pkg, isReset) => {
     projectDef = JSON.stringify(angularPackageDefV14);
   }
   if (packageEuiVersionNumber >= 15) {
-    projectDef = JSON.stringify(angularPackageDefV15);
+    if (pkg.standalone) {
+      projectDef = JSON.stringify(angularPackageDefV15Standalone);
+    } else {
+      projectDef = JSON.stringify(angularPackageDefV15);
+    }
   }
 
   let srcRoot = '/src', srcRootTesting = '';

package/scripts/csdr/config/config-skeletons.js

@@ -1907,7 +1907,51 @@ module.exports.angularPackageDefV15 = {
   }
 };
 
-
+module.exports.angularPackageDefV15Standalone = {
+  "root": "",
+  "sourceRoot": "src",
+  "projectType": "library",
+  "prefix": "lib",
+  "architect": {
+    "lint": {
+      "builder": "@angular-eslint/builder:lint",
+      "options": {
+        "lintFilePatterns": [
+          "**/*.ts",
+          "**/*.html"
+        ],
+        "eslintConfig": ".eslintrc.json"
+      }
+    },
+    "build": {
+      "builder": "@angular-devkit/build-angular:ng-packagr",
+      "options": {
+        "tsConfig": "tsconfig.lib.json",
+        "project": "ng-package.json"
+      },
+      "configurations": {
+        "production": {
+          "tsConfig": "tsconfig.lib.prod.json"
+        }
+      }
+    },
+    "test": {
+      "builder": "@angular-devkit/build-angular:karma",
+      "options": {
+        "polyfills": [
+          "zone.js",
+          "zone.js/testing"
+        ],
+        "tsConfig": "tsconfig.spec.json",
+        "karmaConfig": "karma.conf.js",
+        "scripts": [
+          "node_modules/quill/dist/quill.js",
+          "node_modules/quill-better-table/dist/quill-better-table.min.js"
+        ]
+      }
+    }
+  }
+};
 
 
 module.exports.angularElementProjectDef = {

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

@@ -9,3 +9,4 @@ module.exports.init = require('./init');
 module.exports.sync = require('./sync');
 module.exports.remotes = require('./remotes');
 module.exports.register = require('./register');
+module.exports.standalone = require('./standalone');

package/scripts/csdr/config/packages.js

@@ -121,6 +121,10 @@ module.exports.getPackage = (pkgName, fromCsdrConfig, optional) => {
   // optional call should not do anything
   if (!pkg && optional) return;
 
+  // flagging as CSDR package / non-standalone package
+  pkg.csdr = true;
+  pkg.standlone = false;
+
   // additional pkg infos
   pkg.paths = this.getPackagePaths(pkg);
   pkg.tsConfigFileName = `${path.parse(pkg.paths.tsConfig).name}.json`;
@@ -176,9 +180,9 @@ module.exports.getPackagePaths = (pkg) => {
   const rootDirectory = process.cwd();
   const resolvePath = (relativePath) => path.resolve(rootDirectory, relativePath);
 
-  const packagesBasePath = 'packages';
-
-  const folder = pkg.folder || pkg.name;
+  let packagesBasePath, folder;
+  packagesBasePath = 'packages';
+  folder = pkg.folder || pkg.name;
 
   let packagesPath;
   if (pkg.child) {
@@ -228,6 +232,37 @@ module.exports.getPackagePaths = (pkg) => {
   return paths;
 };
 
+module.exports.getStandalonePackage = () => {
+  const basePath = path.join(process.cwd());
+
+  const packageJsonPath = path.join(basePath, 'package.json');
+
+  if (!tools.isFileExists(packageJsonPath)) {
+    throw new Error('PACKAGE_JSON_NOT_FOUND');
+  }
+
+  // get package.json information (name, current version)
+  const packageJson = require(packageJsonPath);
+
+  const pkg = {
+    csdr: false,
+    standalone: true,
+    ...packageJson,
+    paths: {
+      root: basePath,
+      dist: path.join(basePath, 'dist'),
+      publish: path.join(basePath, 'dist'),
+      src: path.join(basePath, 'src'),
+      lib: path.join(basePath, 'src', 'lib'),
+      srcLib: path.join(basePath, 'src', 'lib'),
+      tsConfig: path.join(basePath, 'tsconfig.lib.json'),
+    }
+  };
+  pkg.tsConfigFileName = `${path.parse(pkg.paths.tsConfig).name}.json`;
+
+  return pkg;
+}
+
 module.exports.getBuildablePackages = () => {
   return this.getPackages().filter((pkg) => {
     if (!pkg.build) {
@@ -338,6 +373,10 @@ const getPackageEuiVersion = (module.exports.getPackageEuiVersion = (pkg, log =
       version = getEuiVersionCore(pkg);
     }
 
+    if (!version && pkg.standalone) {
+      version = getEuiVersionFromPackageJson(pkg);
+    }
+
     if (log) {
       if (version) {
         tools.logInfo(`checking -->${pkg.name}<-- => version found : ${version}\n`);

package/scripts/csdr/config/remotes.js

@@ -39,6 +39,8 @@ module.exports.getRemote = (remoteName) => {
   const remoteRootPath = path.join(process.cwd(), 'remotes', remoteName);
 
   const remote = {
+    csdr: true,
+    standlone: false,
     name: remoteName,
     element: true,
     remote: true,

package/scripts/csdr/config/standalone.js

@@ -0,0 +1,108 @@
+'use strict';
+
+module.exports.getConfigOptions = () => {
+  let configOptions = {
+    SONAR_HOST: null,
+    ISSUES_MANAGER_HOST: null,
+    NPM_REGISTRY_INSTALL: null,
+    NOTIFICATION_CLIENT: null,
+    MSTEAMS_HOST: null,
+    MSTEAMS_FRONTEND_CHANNEL: null,
+    MSTEAMS_BACKEND_CHANNEL: null,
+    MSTEAMS_PROJECT_CHANNEL: null,
+    MSTEAMS_CHANNELS_EMAILS: null,
+  };
+
+  const notificationConfig = {
+    defaultClient: 'MSTEAMS',
+    msteams: {
+      host: 'MSTEAMSHOOK_TO_REPLACE',
+      defaultChannel: 'pipeline-ui',
+      channels: {
+        frontend: 'pipeline-ui',
+      },
+      channelsEmails: {
+        'pipeline-ui': 'EMAIL_CHANNEL_TO_REPLACE',
+      },
+    },
+  };
+
+  const npmConfig = {
+    registry: {
+      install: 'https://csdr-nexus.devops.tech.ec.europa.eu/repository/npm-group/',
+      default: 'https://csdr-nexus.devops.tech.ec.europa.eu/repository/npm-private/',
+    },
+  };
+
+  const sonarConfig = {
+    host: 'https://webgate.ec.europa.eu/CITnet/sonarqube/',
+  };
+
+  const issuesManagerConfig = {
+    host: "https://webgate.ec.europa.eu/CITnet/jira/browse/",
+  };
+
+  // getting npm registry config
+  const npm = npmConfig;
+
+  if (npm) {
+    if (npm.registry && npm.registry.install) {
+      configOptions.NPM_REGISTRY_INSTALL = npm.registry.install;
+    }
+    if (npm.registry && npm.registry.default) {
+      configOptions.NPM_REGISTRY_DEFAULT = npm.registry.default;
+    }
+  }
+
+  // getting issues manager options
+  const issuesManager = issuesManagerConfig;
+
+  if (issuesManager) {
+    if (issuesManager.host) {
+      configOptions.ISSUES_MANAGER_HOST = issuesManager.host;
+    }
+  }
+
+  // getting sonar options
+  const sonar = sonarConfig;
+  if (sonar) {
+    if (sonar.host) {
+      configOptions.SONAR_HOST = sonar.host;
+    }
+  }
+
+  // getting notification options (replacing slack only above)
+  const notification = notificationConfig;
+
+  if (notification) {
+    if (notification.defaultClient) {
+      configOptions.NOTIFICATION_CLIENT = notification.defaultClient;
+    }
+
+    const msteams = notification.msteams;
+
+    if (msteams) {
+      if (msteams.host) {
+        configOptions.MSTEAMS_HOST = msteams.host;
+      }
+
+      if (msteams.channels) {
+        if (msteams.channels.frontend) {
+          configOptions.MSTEAMS_FRONTEND_CHANNEL = msteams.channels.frontend;
+        }
+        if (msteams.channels.backend) {
+          configOptions.MSTEAMS_BACKEND_CHANNEL = msteams.channels.backend;
+        }
+        if (msteams.channels.project) {
+          configOptions.MSTEAMS_PROJECT_CHANNEL = msteams.channels.project;
+        }
+      }
+
+      if (msteams.channelsEmails) {
+        configOptions.MSTEAMS_CHANNELS_EMAILS = msteams.channelsEmails;
+      }
+    }
+  }
+
+  return configOptions;
+};

package/scripts/csdr/install/common.js

@@ -72,14 +72,22 @@ module.exports.installDeps = (deps) => {
   );
 };
 
-const executeInstall = (module.exports.executeInstall = (cwdPath) => {
+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}`);
       }
     })
 

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

@@ -14,11 +14,7 @@ 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 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)

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

@@ -0,0 +1,211 @@
+'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;
+    })
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+'use strict';
+
+// UTILS
+const utils = require('../../../utils');
+
+// CSDR RELATED
+const configUtils = require('../../config/config-utils');
+const auditUtils = require('../../audit/audit-utils');
+const installUtils = require('../../install/install-utils');
+
+// INNER MODULES
+const innerCommon = require('./common');
+
+
+module.exports.run = () => {
+  // pre-requisites : package repository cloned - on gitlab script is run on the repo pipeline itself
+
+  const { dryRun } = utils.tools.getArgs();
+
+  utils.tools.logBanner('Starting UI stand-alone pipeline');
+
+  // local saved vars
+  let newVersion, commitsMetadata;
+
+  // getting the package information - mimics CSDR package config
+  const pkg = configUtils.packages.getStandalonePackage();
+
+  // get branches config
+  const branches = innerCommon.getBranchesFromRepo();
+
+  // get global config options
+  const configOptions = configUtils.standalone.getConfigOptions();
+
+  return (
+    Promise.resolve()
+
+      // RELEASE PACKAGE START
+
+      // Starting the release flow
+      .then(() => {
+        return innerCommon.initMessage(pkg, branches);
+      })
+
+      // CHECK BRANCH VALIDITY
+      .then(() => {
+        innerCommon.checkBranchValidity(branches);
+      })
+
+      // COMMIT METADATA CHECKS
+      .then(() => {
+        return innerCommon.commitMetadataChecks(pkg);
+      })
+      .then((metadata) => {
+        commitsMetadata = metadata;
+      })
+
+
+      // INIT PACKAGE CONFIG
+      .then(() => {
+        // generating angular.json config if not existing
+        configUtils.angular.checkAngularConfig();
+
+        // registering package angular config
+        configUtils.angular.registerAngularPackage(pkg);
+      })
+
+      // INIT ROOT FILES - yarn lock and resolution based on current eUI version of the package
+      // TODO - get the raw eUI version from package.json dependencies - need to test and adapt the config.global.getLocalEuiversion
+      // .then(() => {
+      //   return initUtils.global.initRootFilesAndResolutions();
+      // })
+
+
+      // INSTALL dependencies by type
+      .then(() => {
+        utils.tools.logBanner('INSTALL DEPENDENCIES');
+
+        return (
+          Promise.resolve()
+            // executing install for current package - based on package.json
+            .then(() => {
+              return installUtils.common.executeInstall(process.cwd(), configOptions.NPM_REGISTRY_INSTALL);
+            })
+
+            // auditing dependencies
+            .then(() => {
+              return auditUtils.yarn.audit(pkg);
+            })
+            .catch((e) => {
+              throw e;
+            })
+        );
+      })
+
+      // BUILD PACKAGE
+      .then(() => {
+        return utils.buildPackage.build(pkg, branches.isMaster, false);
+      })
+
+      // EXECUTING SONAR ANALYSIS
+      .then(() => {
+        return utils.sonar.run(pkg, branches.isMaster);
+      })
+
+      // GENERATE and UPDATE new version
+      .then(() => {
+        return innerCommon.updateVersion(pkg, commitsMetadata);
+      })
+      .then((version) => {
+        // storing version for later use
+        newVersion = version;
+      })
+
+      // GENERATE CHANGELOG
+      .then(() => {
+        utils.tools.logTitle('generating changelog...');
+        return utils.changelog.generate(pkg, newVersion, commitsMetadata.commits);
+      })
+
+      // WRITE CHANGELOG for MASTER and SUPPORT
+      .then((changelogContent) => {
+        utils.tools.logTitle('writing changelog...');
+
+        if ((branches.isSupport || branches.isNext || branches.isMaster) && !dryRun) {
+          return utils.changelog.writeChangelog(changelogContent, pkg.paths.root);
+
+        } else {
+          utils.tools.logInfo('WRITING SKIPPED - (either DRY-RUN or snapshot release) - Actual changelog :');
+          console.log(changelogContent);
+        }
+      })
+
+      // PUBLISH PACKAGE
+      .then(() => {
+        return utils.publish.publish(pkg);
+      })
+
+      // GIT OPERATIONS
+      .then(() => {
+        return innerCommon.commitPackage(pkg, newVersion, branches);
+      })
+      .then(() => {
+        return innerCommon.tagAndMerge(pkg, newVersion, branches);
+      })
+
+      // SEND SUCCESS NOTIFICATION
+      .then(() => {
+        return innerCommon.sendSuccessNotification(pkg, newVersion, commitsMetadata, false).then(() => {
+          return innerCommon.close(pkg);
+        });
+      })
+
+      // SEND ERROR NOTIFICATION
+      .catch((e) => {
+        return innerCommon
+          .sendErrorNotification(pkg, e, commitsMetadata, false)
+          .then(() => {
+            return innerCommon.close(pkg);
+          })
+          .then(() => {
+            process.exit(1);
+          });
+      })
+  );
+};