@eui/tools 6.2.33 → 6.2.34

package/.version.properties

@@ -1 +1 @@
-6.2.33
+6.2.34

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 6.2.34 (2022-11-16)
+
+##### Chores
+
+* **cli:**
+  * generation of virtual remotes v15 - cleanup and refactoring for v10 v15 - EUI-6825 [EUI-6825](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-6825)  ([33e1ba9f](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/33e1ba9f838aafdde78ba8d0cdad44ed72e196c3))
+
+* * *
+* * *
 ## 6.2.33 (2022-11-16)
 
 ##### Chores

package/package.json

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

package/scripts/csdr/cli/constants.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const path = require('path');
+
+module.exports.TARGET_ROOT_PATH = path.join(process.cwd(), 'packages');
+module.exports.TARGET_ROOT_REMOTES_PATH = path.join(process.cwd(), 'remotes');
+module.exports.SKELETONS_ROOT_PATH = path.join(__dirname, 'skeletons', 'package');
+module.exports.FRONTEND_SKELETON_EUI10_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-eui10');
+module.exports.FRONTEND_SKELETON_EUI15_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-eui15');
+module.exports.FRONTEND_SKELETON_REMOTE_EUI10_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-remote-eui10');
+module.exports.FRONTEND_SKELETON_REMOTE_EUI15_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-remote-eui15');
+module.exports.FRONTEND_OPTION_ROUTE_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-option-route');
+module.exports.BACKEND_SKELETON_PATH = path.join(this.SKELETONS_ROOT_PATH, 'backend');
+module.exports.VIRTUAL_REMOTE_SKELETON_ROOT_PATH = path.join(__dirname, 'skeletons', 'virtual-remote');
+
+module.exports.CONFIG_OPTIONS = {
+  pkgType: {
+    FRONTEND: 'frontend',
+    BACKEND: 'backend'
+  },
+  pkgFrontendType: {
+    DEFAULT: 'default',
+    REMOTE: 'remote'
+  },
+  pkgFrontendVersion: {
+    EUI10: '10',
+    EUI15: '15',
+  }
+}
+
+module.exports.DEFAULT_CONFIG = {
+  pkgType: this.CONFIG_OPTIONS.pkgType.FRONTEND,
+  pkgFrontendType: this.CONFIG_OPTIONS.pkgFrontendType.DEFAULT,
+  pkgFrontendVersion: this.CONFIG_OPTIONS.pkgFrontendVersion.EUI10,
+  pkgName: 'my-package',
+  pkgScope: '@zzz',
+  isRouteModule: true,
+  isCsdrRepo: true,
+  isEnvTargetRemote: true,
+  isVirtualRemote: false,
+  externalRepoName: null,
+  pkgGroupId: 'eu.europa.ec.cc'
+};

package/scripts/csdr/cli/package-build-backend.js

@@ -0,0 +1,70 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// LOCAL
+const tools = require('../../../scripts/utils/tools');
+
+// CONSTANTS
+const constants = require('./constants');
+
+
+
+module.exports.generate = (name, scope, groupId) => {
+
+  tools.logTitle('Generating package');
+
+  const artifactId = scope.substr(1, scope.length) + '-' + name + '-backend';
+
+  const targetPath = path.join(constants.TARGET_ROOT_PATH, artifactId);
+
+
+  return Promise.resolve()
+
+    // CLEANING TARGET
+    .then(() => {
+      tools.logInfo('Cleaning target');
+      return tools.rimraf(targetPath + '/**/*');
+    })
+
+
+    // COPY TO TARGET
+    .then(() => {
+      tools.logInfo('Copying skeleton to target');
+      return tools.copydir(constants.BACKEND_SKELETON_PATH, targetPath, true);
+    })
+
+
+    // REPLACING PLACEHOLDERS
+    .then(() => {
+      tools.logInfo('Replacing placeholders');
+
+      return Promise.resolve()
+        .then(() => {
+          return tools.replaceInPath(targetPath, '@groupId@', groupId);
+        })
+        .then(() => {
+          return tools.replaceInPath(targetPath, '@artifactId@', artifactId);
+        })
+        .catch((e) => {
+          throw e;
+        })
+    })
+
+    .then(() => {
+      tools.logInfo('Executing post build operations');
+      return tools.move(path.join(targetPath, 'gitignore_TO_REPLACE'), path.join(targetPath, '.gitignore'));
+    })
+
+    .then(() => {
+      tools.logSuccess();
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+

package/scripts/csdr/cli/package-build-frontend.js

@@ -0,0 +1,300 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// LOCAL
+const tools = require('../../../scripts/utils/tools');
+const configUtils = require('../config/config-utils');
+const initUtils = require('../init/init-utils');
+
+// CONSTANTS
+const constants = require('./constants');
+
+
+
+
+const init = (frontendType, rootPackagePath, targetPath) => {
+  return Promise.resolve()
+
+    // CHECKING presence of UI package supporting the remote
+    .then(() => {
+      if (frontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE && !tools.isDirExists(rootPackagePath)) {
+        tools.logError(`${rootPackagePath} NOT FOUND, you must mount the root package ui before creating the remote`);
+        throw new Error('ROOT_PACKAGE_NOT_FOUND');
+      }
+    })
+
+    // CLEANING TARGET
+    .then(() => {
+      tools.logInfo('Cleaning target');
+      return tools.rimraf(targetPath + '/**/*');
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+const replaceExtensions = (targetPath) => {
+  return Promise.resolve()
+
+    .then(() => {
+      tools.logInfo('Executing post generation operations');
+      tools.move(path.join(targetPath, 'gitignore_TO_REPLACE'), path.join(targetPath, '.gitignore'));
+      if (tools.isFileExists(path.join(targetPath, 'package.json_TO_REPLACE'))) {
+        tools.move(path.join(targetPath, 'package.json_TO_REPLACE'), path.join(targetPath, 'package.json'));
+      }
+    })
+    .then(() => {
+      tools.logInfo('Replace extensions');
+      return tools.removeFilesExtension(targetPath, '.TO_REPLACE');
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+const replaceContent = (targetPath, name, scope, fullName) => {
+  tools.replaceInPath(targetPath, '@module.name@', name);
+  tools.replaceInPath(targetPath, '@module.full.name@', fullName);
+  tools.replaceInPath(targetPath, '@module.scope@', scope);
+  tools.replaceInPath(targetPath, '@module.scope-name@', `${scope.substr(1)}-${name}`);
+  tools.replaceInPath(targetPath, '@module.scope.string@', scope.substr(1));
+  tools.replaceInPath(targetPath, '@module.class.name@', tools.camelCaseString(name, '-', true));
+}
+
+
+
+
+const generateVirtualRemote = ({fullName, targetPath, rootPackagePath, pkg, args = constants.DEFAULT_CONFIG}) => {
+
+  tools.logInfo('Generate virtual remote');
+
+  const remoteTargetPath = path.join(process.cwd(), 'packages', 'csdr-remotes-config', 'assets', fullName);
+
+  return Promise.resolve()
+    // INIT and cleanup
+    .then(() => {
+      return init(args.pkgFrontendType, rootPackagePath, targetPath);
+    })
+
+    // COPY FIRST THE REMOTE SKELETON TO TARGET
+    .then(() => {
+      tools.logInfo('Copying skeleton to target');
+
+      // for the moment the virtual remotes are only activated for v15+
+      if (args.pkgFrontendVersion == constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15) {
+        tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI10_PATH, targetPath, true);
+        tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI15_PATH, targetPath, true);
+      }
+
+      // REPLACING PLACEHOLDERS
+      tools.logInfo('Replace sources content');
+      replaceContent(targetPath, args.pkgName, args.pkgScope, fullName);
+
+      // ADDING CONFIG ENTRY - specific csdr-remotes as of v15+
+      tools.logInfo('Adding CSDR config entry');
+      configUtils.register.registerCsdrPackage(
+        pkg, args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE,
+        args.pkgScope, args.pkgName, args.pkgFrontendVersion
+      );
+
+      // REPLACE EXTENSIONS (package.json, .gitignore as the interfere with build of tools if release without name changes)
+      replaceExtensions(targetPath);
+    })
+
+    // ENV TARGET / a-la-carte specific (always true as of v15+ remotes) - TRANSFER The sources from current remote sources
+    .then(() => {
+      // envTarget remote type specific
+      if (args.isEnvTargetRemote) {
+        tools.logInfo('Moving sources from remote to root package for envTarget remote type');
+        return tools.move(path.join(targetPath, 'src'), path.join(rootPackagePath, 'assets', 'remote-sources'));
+      }
+    })
+
+    // CLEANING REMOTES CONFIG ENTRY
+    .then(() => {
+      tools.logInfo('Cleaning csdr-remotes-config target entry');
+      return tools.rimraf(remoteTargetPath + '/**/*');
+    })
+
+    // REPLACING CONTENT FOR VIRTUAL REMOTE CONFIG SKELETON
+    .then(() => {
+      tools.copy(
+        path.join(constants.VIRTUAL_REMOTE_SKELETON_ROOT_PATH, `${args.pkgFrontendVersion}.x`),
+        remoteTargetPath
+      );
+
+      tools.logInfo('Replace sources content in csdr-remotes-config target entry');
+      replaceContent(remoteTargetPath, args.pkgName, args.pkgScope, fullName);
+    })
+
+    // CLEANING REMOTE CURRENT TARGET as this is completetely re-generated by the generateVirtualRemotes() function (same as init)
+    .then(() => {
+      return tools.rimraf(targetPath + '/**/*');
+    })
+
+    // GENERATE THE VIRTUAL REMOTE (as it's dynamically generated, we use here the same fn call as the init)
+    .then(() => {
+      return initUtils.remotes.generateVirtualRemote(fullName, false);
+    })
+
+    .then(() => {
+      tools.logSuccess();
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+
+const generateDefault = ({fullName, targetPath, rootPackagePath, pkg, args = constants.DEFAULT_CONFIG}) => {
+
+  return Promise.resolve()
+    // INIT and cleanup
+    .then(() => {
+      return init(args.pkgFrontendType, rootPackagePath, targetPath);
+    })
+
+    // COPY TO TARGET
+    .then(() => {
+      tools.logInfo('Copying skeleton to target');
+      if (args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE) {
+        if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI10) {
+          tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI10_PATH, targetPath, true);
+
+        } else if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15) {
+          tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI10_PATH, targetPath, true);
+          tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI15_PATH, targetPath, true);
+        }
+
+      } else {
+        if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI10) {
+          tools.copydir(constants.FRONTEND_SKELETON_EUI10_PATH, targetPath, true);
+
+        } else if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15) {
+          tools.copydir(constants.FRONTEND_SKELETON_EUI10_PATH, targetPath, true);
+          tools.copydir(constants.FRONTEND_SKELETON_EUI15_PATH, targetPath, true);
+        }
+      }
+
+      if (args.isRouteModule) {
+        tools.copydir(constants.FRONTEND_OPTION_ROUTE_PATH, targetPath, true);
+      }
+
+      // REPLACING PLACEHOLDERS
+      tools.logInfo('Replace sources content');
+      replaceContent(targetPath, args.pkgName, args.pkgScope, fullName);
+
+      // REGISTERING PACKAGE in CSDR GLOBAL CONFIG
+      tools.logInfo('Registering package');
+
+      tools.logInfo('Adding CSDR config entry');
+      configUtils.register.registerCsdrPackage(
+        pkg, args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE,
+        args.pkgScope, args.pkgName, args.pkgFrontendVersion
+      );
+
+      if (args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.DEFAULT) {
+        configUtils.angular.registerAngularPackage(pkg);
+        configUtils.angular.registerModulePaths(pkg);
+      }
+
+      replaceExtensions(targetPath);
+    })
+
+    .then(() => {
+      if (args.isEnvTargetRemote) {
+        tools.logInfo('Moving sources from remote to root package for envTarget remote type');
+        return tools.move(path.join(targetPath, 'src'), path.join(rootPackagePath, 'assets', 'remote-sources'));
+      }
+    })
+
+    .then(() => {
+      tools.logSuccess();
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+module.exports.generate = (args = constants.DEFAULT_CONFIG) => {
+  tools.logTitle('Generating frontend package');
+
+  let npmPkgName, repoName;
+  let fullName = args.pkgScope.substring(1) + '-' + args.pkgName;
+
+  if (args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.DEFAULT) {
+    fullName += '-ui';
+    npmPkgName = `${args.pkgScope}/${args.pkgName}`;
+
+  } else if (args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE) {
+    if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI10) {
+      fullName += '-eui10-remote-el-ui';
+      npmPkgName = `${args.pkgScope}/${args.pkgName}-eui10-remote-el`;
+
+    } else if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15) {
+      fullName += '-eui15-remote-el-ui';
+      npmPkgName = `${args.pkgScope}/${args.pkgName}-eui15-remote-el`;
+    }
+  }
+
+  // generating default git repo
+  if (args.isCsdrRepo) {
+    repoName = `${fullName}.git`;
+  } else {
+    repoName = `${args.externalRepoName}/${fullName}.git`;
+  }
+
+  // generating target paths
+  let targetPath, rootPackagePath;
+
+  if (args.isVirtualRemote) {
+    // virtual remotes are generated into /remotes root folder
+    targetPath = path.join(constants.TARGET_ROOT_REMOTES_PATH, fullName);
+  } else {
+    // normal remote / packages are generated into /packages root folder
+    targetPath = path.join(constants.TARGET_ROOT_PATH, fullName);
+  }
+
+  // generating rootPackagePath : the linked package with the envTarget/a-la-carte remote setup (now default)
+  rootPackagePath = path.join(constants.TARGET_ROOT_PATH, `${args.pkgScope.substring(1)}-${args.pkgName}-ui`);
+
+  // generating default package entries
+  const pkg = {
+    name: fullName,
+    repoName: repoName,
+    npmPkgName: npmPkgName,
+    paths: {
+      root: rootPackagePath
+    }
+  };
+
+  return Promise.resolve()
+    .then(() => {
+      if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15 && args.isVirtualRemote) {
+        return generateVirtualRemote({fullName, targetPath, rootPackagePath, pkg, args});
+      } else {
+        return generateDefault({fullName, targetPath, rootPackagePath, pkg, args});
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+
+
+
+

package/scripts/csdr/cli/package-prompt.js

@@ -0,0 +1,123 @@
+'use strict';
+
+// GLOBAL
+const inquirer = require('inquirer');
+
+// CONSTANTS
+const constants = require('./constants');
+
+
+module.exports.prompt = () => {
+
+  return Promise.resolve()
+    .then(() => {
+      return inquirer.prompt([
+        {
+          type: 'list',
+          name: 'pkgType',
+          message: 'Select a package type :',
+          choices: [
+            { name: 'Frontend - Angular library', value: constants.CONFIG_OPTIONS.pkgType.FRONTEND },
+            { name: 'Backend - SpringBoot micro-service', value: constants.CONFIG_OPTIONS.pkgType.BACKEND },
+          ],
+          default: constants.DEFAULT_CONFIG.pkgType,
+          validate: function (value) {
+            if (value.length) {
+              return true;
+            }
+          }
+        },
+        {
+          name: 'pkgGroupId',
+          type: 'input',
+          message: 'Enter the Maven groupId :',
+          default: constants.DEFAULT_CONFIG.pkgGroupId,
+          when: function (answers) {
+            return (answers.pkgType === constants.CONFIG_OPTIONS.pkgType.BACKEND);
+          }
+        },
+        {
+          type: 'list',
+          name: 'pkgFrontendType',
+          message: 'Select a frontend type :',
+          choices: [
+            { name: 'Default Angular library', value: constants.CONFIG_OPTIONS.pkgFrontendType.DEFAULT },
+            { name: 'Remote element micro-frontend', value: constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE },
+          ],
+          default: constants.DEFAULT_CONFIG.pkgFrontendType,
+          when: function (answers) {
+            return (answers.pkgType === constants.CONFIG_OPTIONS.pkgType.FRONTEND);
+          },
+          validate: function (value) {
+            if (value.length) {
+              return true;
+            }
+          }
+        },
+        {
+          type: 'list',
+          name: 'pkgFrontendVersion',
+          message: 'Select eUI version target :',
+          choices: [
+            { name: 'v10', value: constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI10 },
+            { name: 'v15', value: constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15 },
+          ],
+          default: constants.DEFAULT_CONFIG.pkgFrontendType,
+          when: function (answers) {
+            return (answers.pkgType === constants.CONFIG_OPTIONS.pkgType.FRONTEND);
+          },
+          validate: function (value) {
+            if (value.length) {
+              return true;
+            }
+          }
+        },
+        {
+          name: 'pkgScope',
+          type: 'input',
+          message: 'Enter the package scope :',
+          default: constants.DEFAULT_CONFIG.pkgScope
+        },
+        {
+          name: 'pkgName',
+          type: 'input',
+          message: 'Enter the package name :',
+          default: constants.DEFAULT_CONFIG.pkgName
+        },
+        {
+          name: 'isRouteModule',
+          type: 'confirm',
+          message: 'Is this a ROUTE package ?',
+          default: constants.DEFAULT_CONFIG.isRouteModule,
+          when: function (answers) {
+            return (
+              answers.pkgType === constants.CONFIG_OPTIONS.pkgType.FRONTEND &&
+              answers.pkgFrontendType !== constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE
+            );
+          }
+        },
+        {
+          name: 'isCsdrRepo',
+          type: 'confirm',
+          message: 'Is the repository within CSDR git project ?',
+          default: constants.DEFAULT_CONFIG.isCsdrRepo
+        },
+        {
+          name: 'externalRepoName',
+          type: 'input',
+          message: 'Enter the project CITnet project name where the repository is located :',
+          default: constants.DEFAULT_CONFIG.externalRepoName,
+          when: function (answers) {
+            return (
+              answers.isCsdrRepo === false
+            );
+          }
+        },
+      ]);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+