@eui/tools 4.19.6 → 4.19.7

package/.version.properties

@@ -1 +1 @@
-4.19.6
+4.19.7

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 4.19.7 (2022-02-13)
+
+##### Chores
+
+* **other:**
+  * activate route replacement - added backward compatibility with current route replacement for higher envs - MWP-7941 [MWP-7941](https://webgate.ec.europa.eu/CITnet/jira/browse/MWP-7941)  ([be5735d6](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/be5735d645e360389b64da44b2b9fcae4739febf))
+
+* * *
+* * *
 ## 4.19.6 (2022-02-07)
 
 ##### Bug Fixes

package/global.test.js

@@ -28,6 +28,7 @@ describe('eUI tools - test imports', () => {
     const prebuildInjectionConfig = require('./scripts/utils/pre-build/injection/config');
     const prebuildInjectionSkeletons = require('./scripts/utils/pre-build/injection/skeletons');
     const prebuildInjectionExternals = require('./scripts/utils/pre-build/injection/externals');
+    const prebuildInjectionRoutesReplacement = require('./scripts/utils/pre-build/injection/routes-replacement');
 
     // utils -pre-build - translations
     const prebuildTranslationUtils = require('./scripts/utils/pre-build/translations/translation-utils');

package/package.json

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

package/sandbox.js

@@ -648,5 +648,6 @@ return Promise.resolve()
   //   return injectionUtils.externals.injectExternalAppSources(prj);
   // })
   .then(() => {
-    return injectionUtils.externals.remapRoutesByEnvConfig(prj, 'DEV', true);
+    // return injectionUtils.externals.remapRoutesByEnvConfig(prj, 'DEV', true);
+    return injectionUtils.routesReplacement.buildRoutes(prj, 'DEV', false);
   })

package/scripts/utils/pre-build/injection/externals.js

@@ -9,7 +9,7 @@ const configUtils = require('../../../csdr/config/config-utils');
 
 module.exports.injectExternalFeatures = (project) => {
 
-  tools.logInfo(`Injecting project external features for : ${project.name}`);
+  tools.logTitle(`Injecting project external features for : ${project.name}`);
 
   return Promise.resolve()
     .then(() => {
@@ -66,7 +66,7 @@ module.exports.injectExternalFeatures = (project) => {
 
 module.exports.injectExternalAppSources = (project) => {
 
-  tools.logInfo(`Injecting project external application sources for : ${project.name}`);
+  tools.logTitle(`Injecting project external application sources for : ${project.name}`);
 
   return Promise.resolve()
     .then(() => {
@@ -123,7 +123,7 @@ module.exports.injectExternalAppSources = (project) => {
 
 module.exports.injectElementExternalSources = (pkg) => {
 
-  tools.logInfo(`Injecting package external sources for : ${pkg.name}`);
+  tools.logTitle(`Injecting package external sources for : ${pkg.name}`);
 
   return Promise.resolve()
     .then(() => {
@@ -181,7 +181,7 @@ module.exports.injectElementExternalSources = (pkg) => {
 
 module.exports.injectExternalMock = (project) => {
 
-  tools.logInfo(`Injecting project external mock for : ${project.name}`);
+  tools.logTitle(`Injecting project external mock for : ${project.name}`);
 
   return Promise.resolve()
     .then(() => {
@@ -197,148 +197,3 @@ module.exports.injectExternalMock = (project) => {
       throw e;
     })
 }
-
-module.exports.remapRoutesByEnvConfig = (project, envTarget, build) => {
-  tools.logInfo(`Remapping routes by env config for ${envTarget}`);
-
-  return Promise.resolve()
-    .then(() => {
-      // getting config file
-      const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
-      let configFile;
-
-      // build - envTarget based
-      if (build) {
-        let envTargetFinal = envTarget.toLowerCase();
-        // dirty fix as openid files do not respect envTarget names
-        if (envTargetFinal === 'tst') {
-          envTargetFinal = 'test';
-        }
-        configFile = path.join(projectAssetsPath, 'openid-login-config.' + envTargetFinal + '.json');
-
-      // serve configuration based
-      } else {
-        if (envTarget.indexOf('local') > -1) {
-          configFile = path.join(projectAssetsPath, 'openid-login-config.' + envTarget.replace('-openid', '') + '.json');
-        } else {
-          configFile = path.join(projectAssetsPath, 'openid-login-config.local-' + envTarget + '.json');
-        }
-      }
-
-      tools.logInfo(`checking ${configFile}`);
-      if (!tools.isFileExists(configFile)) {
-        tools.logError(`config file for ${envTarget} do not exists`);
-        return;
-      }
-
-      // getting config file content and checking if routesRemapping is set
-      const config = require(configFile);
-      const routesRemapping = config.routesRemapping;
-      if (!routesRemapping) {
-        tools.logWarning('No routes remapping found in current config...skipping');
-        return;
-      }
-
-      // checking is routes path declared
-      if (!project.appSources.routesFilePath) {
-        tools.logError('project appSources.routesFilePath is not declared in app config');
-        return;
-      }
-
-      // checking is routes file exists
-      const routesFilePath = path.join(project.paths.rootPath, project.appSources.routesFilePath);
-      if (!tools.isFileExists(routesFilePath)) {
-        tools.logError(`Unable to find routes files : ${routesFilePath}`);
-        return;
-      }
-
-      let routesFileContent = tools.getFileContent(routesFilePath);
-
-      // get routes file content and replace tokens
-      routesRemapping.forEach((route) => {
-        tools.logInfo(`\nchecking replacement for : ${JSON.stringify(route)}`);
-        const tokenToSearch = `./features/${route.featureModule}-lib.module#Module`;
-        tools.logInfo(`Searching token : ${tokenToSearch}`);
-        if (routesFileContent.indexOf(tokenToSearch) > -1) {
-          tools.logInfo(`token ${tokenToSearch} found...replacing by ${route.routeModuleDef}`);
-          routesFileContent = tools.replaceAll(routesFileContent, tokenToSearch, route.routeModuleDef);
-        } else {
-          tools.logWarning(`token ${tokenToSearch} NOT FOUND`);
-        }
-      })
-
-      // extra physical routes remapping
-      const extraRoutesRemapping = config.extraRoutesRemapping;
-      if (!extraRoutesRemapping) {
-        tools.logWarning('No extra routes remapping found in current config...skipping');
-
-      } else {
-        tools.logInfo('Extra routes remapping');
-        extraRoutesRemapping.forEach((route) => {
-          tools.logInfo(`checking replacement ${JSON.stringify(route)}`);
-          const tokenToSearch = route.currentRoute;
-          if (routesFileContent.indexOf(tokenToSearch) > -1) {
-            tools.logInfo(`token ${tokenToSearch} found...replacing by ${route.updatedRoute}`);
-            routesFileContent = tools.replaceAll(routesFileContent, tokenToSearch, route.updatedRoute);
-          } else {
-            tools.logWarning(`token ${tokenToSearch} NOT FOUND`);
-          }
-        })
-      }
-
-      // checking paths mapping (new method for v10 remotes)
-      const pathsMapping = config.pathsMapping;
-      if (!pathsMapping) {
-        tools.logWarning('No pathsMapping found in current config...skipping');
-
-      } else {
-        tools.logInfo('Paths mappings for v10 remotes activation');
-        pathsMapping.forEach((pathMapping) => {
-          tools.logInfo(`Checking path: ${pathMapping.path}`);
-          const placeholderToSearch = `// ${pathMapping.path}-placeholder`;
-
-          if (routesFileContent.indexOf(placeholderToSearch) > -1) {
-            tools.logInfo(`path placeholder: "${placeholderToSearch}" found...replacing`);
-
-            let placeholderContent = '';
-            if (pathMapping.data) {
-              placeholderContent += 'data:{';
-              if (pathMapping.data.featureName) {
-                placeholderContent += `featureName: "${pathMapping.data.featureName}"`;
-              }
-              if (pathMapping.data.moduleId) {
-                placeholderContent += `, moduleId: "${pathMapping.data.moduleId}"`;
-              }
-              if (pathMapping.data.elementTag) {
-                placeholderContent += `, elementTag: "${pathMapping.data.elementTag}"`;
-              }
-              if (pathMapping.data.iframe) {
-                placeholderContent += `, iframe: ${pathMapping.data.iframe}`;
-              }
-              placeholderContent += '}';
-            }
-            if (pathMapping.loadChildren) {
-              placeholderContent += `, loadChildren: "${pathMapping.loadChildren}"`;
-            }
-
-            tools.logInfo('Generated content for route: ');
-            console.log(placeholderContent);
-
-            routesFileContent = tools.replaceAll(routesFileContent, placeholderToSearch, placeholderContent);
-
-          } else {
-            tools.logWarning(`token ${placeholderToSearch} NOT FOUND`);
-          }
-        })
-      }
-
-      return tools.writeFileContent(routesFilePath, routesFileContent);
-    })
-    .then(() => {
-      tools.logSuccess();
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}

package/scripts/utils/pre-build/injection/injection-utils.js

@@ -4,8 +4,10 @@
 const innerConfig = require('./config');
 const innerSkeletons = require('./skeletons');
 const innerExternals = require('./externals');
+const innerRoutesReplacement = require('./routes-replacement');
 
 // re-exports inner modules
 module.exports.config = innerConfig;
 module.exports.skeletons = innerSkeletons;
 module.exports.externals = innerExternals;
+module.exports.routesReplacement = innerRoutesReplacement;

package/scripts/utils/pre-build/injection/routes-replacement.js

@@ -0,0 +1,312 @@
+'use strict';
+
+const path = require('path');
+const _ = require('lodash');
+
+const tools = require('../../tools');
+const configUtils = require('../../../csdr/config/config-utils');
+
+
+const getEnvConfig = (project, envTarget, build) => {
+  tools.logInfo(`Getting config file for env : ${envTarget}`);
+
+  return Promise.resolve()
+    .then(() => {
+      // getting config file
+      const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
+      let configFile;
+
+      // build - envTarget based
+      if (build) {
+        let envTargetFinal = envTarget.toLowerCase();
+        // dirty fix as openid files do not respect envTarget names
+        if (envTargetFinal === 'tst') {
+          envTargetFinal = 'test';
+        }
+        configFile = path.join(projectAssetsPath, 'openid-login-config.' + envTargetFinal + '.json');
+
+      // serve configuration based
+      } else {
+        if (envTarget.indexOf('local') > -1) {
+          configFile = path.join(projectAssetsPath, 'openid-login-config.' + envTarget.replace('-openid', '') + '.json');
+        } else {
+          configFile = path.join(projectAssetsPath, 'openid-login-config.local-' + envTarget + '.json');
+        }
+      }
+
+      tools.logInfo(`checking ${configFile}`);
+      if (!tools.isFileExists(configFile)) {
+        tools.logError(`config file for ${envTarget} do not exists`);
+        return;
+      }
+
+      return require(configFile);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+const getRoutesFile = (project, isFullReplacement) => {
+  tools.logInfo('Getting routes file for replacement');
+
+  return Promise.resolve()
+    .then(() => {
+      if (!project.appSources) {
+        tools.logError('project requires appSources definition');
+        return;
+      }
+
+      let routesFilePath;
+
+      if (isFullReplacement) {
+        let srcRoutesFilePath;
+
+        if (!project.appSources.routesFileNpmPkg || !project.appSources.routesFileSource || !project.appSources.routesFilePath) {
+          tools.logError('project requires appSources.routesFileNpmPkg, routesFileSources and routesFilePath definitions');
+          return;
+        }
+
+        // check if package is locally cloned
+        const localPackage = configUtils.packages.getPackages().filter((p) => {
+          return p.npmPkg === project.appSources.routesFileNpmPkg
+        })[0];
+
+        // if local package is found
+        if (localPackage) {
+          tools.logInfo('local package found, copying from local');
+          srcRoutesFilePath = path.join(process.cwd(), 'packages', localPackage.name, project.appSources.routesFileSource);
+
+        // if not sources are taken from the npm package def in node_modules
+        } else {
+          tools.logInfo('remote package found, copying from remote');
+          const npmPkgScope = project.appSources.routesFileNpmPkg.substr(0, project.appSources.routesFileNpmPkg.indexOf('/'));
+          const npmPkgName = project.appSources.routesFileNpmPkg.substr(project.appSources.routesFileNpmPkg.indexOf('/') + 1);
+
+          srcRoutesFilePath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, project.appSources.routesFileSource);
+        }
+
+        routesFilePath = path.join(project.paths.rootPath, project.appSources.routesFilePath);
+
+        // copy source file to project destination
+        tools.copy(srcRoutesFilePath, routesFilePath);
+
+      } else {
+        if (!project.appSources.routesFilePath) {
+          tools.logError('project requires appSources.routesFilePath definition');
+          return;
+        }
+
+        routesFilePath = path.join(project.paths.rootPath, project.appSources.routesFilePath);
+      }
+
+      // checking is routes path declared
+      if (!tools.isFileExists(routesFilePath)) {
+        tools.logError(`Unable to find ${routesFilePath}`);
+        return;
+      }
+
+      return routesFilePath;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+const remapRoutes = (config, routesFileContent) => {
+  tools.logInfo('config.routesRemapping found...Staring routes remapping');
+
+  console.log(routesFileContent);
+
+  return Promise.resolve()
+    .then(() => {
+      config.routesRemapping.forEach((route) => {
+        tools.logInfo(`\nchecking replacement for : ${JSON.stringify(route)}`);
+        const tokenToSearch = `./features/${route.featureModule}-lib.module#Module`;
+        tools.logInfo(`Searching token : ${tokenToSearch}`);
+        if (routesFileContent.indexOf(tokenToSearch) > -1) {
+          tools.logInfo(`token ${tokenToSearch} found...replacing by ${route.routeModuleDef}`);
+          routesFileContent = tools.replaceAll(routesFileContent, tokenToSearch, route.routeModuleDef);
+        } else {
+          tools.logWarning(`token ${tokenToSearch} NOT FOUND`);
+        }
+      })
+
+      if (!config.extraRoutesRemapping) {
+        tools.logWarning('No extra routes remapping found in current config...skipping');
+
+      } else {
+        tools.logInfo('Extra routes remapping');
+        config.extraRoutesRemapping.forEach((route) => {
+          tools.logInfo(`checking replacement ${JSON.stringify(route)}`);
+          const tokenToSearch = route.currentRoute;
+          if (routesFileContent.indexOf(tokenToSearch) > -1) {
+            tools.logInfo(`token ${tokenToSearch} found...replacing by ${route.updatedRoute}`);
+            routesFileContent = tools.replaceAll(routesFileContent, tokenToSearch, route.updatedRoute);
+          } else {
+            tools.logWarning(`token ${tokenToSearch} NOT FOUND`);
+          }
+        })
+      }
+
+      return routesFileContent;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+const replaceRoutes = (project, envTarget, build, routesFileContent) => {
+  tools.logInfo('config.routesRemapping not found...Starting full routes replacement');
+
+  return Promise.resolve()
+    .then(() => {
+      // getting base route defs content
+      const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
+      const baseRouteDefsPath = path.join(projectAssetsPath, 'route-defs-base.json');
+
+      if (!tools.isFileExists(baseRouteDefsPath)) {
+        tools.logError(`${baseRouteDefsPath} File NOT FOUND`);
+        throw 'BASE_ROUTE_DEFS_FILE_NOT_FOUND';
+      }
+
+      const baseRouteDefsJSON = require(baseRouteDefsPath);
+
+      // getting env route defs content if build mode (not serve)
+      let envRouteDefsPath, envRouteDefsJSON = [];
+      if (build) {
+        envRouteDefsPath = path.join(projectAssetsPath, 'route-defs.' + envTarget.toLowerCase() + '.json');
+
+        if (!tools.isFileExists(envRouteDefsPath)) {
+          tools.logError(`${envRouteDefsPath} File NOT FOUND`);
+          throw 'ENV_ROUTE_DEFS_FILE_NOT_FOUND';
+        }
+        envRouteDefsJSON = require(envRouteDefsPath);
+      }
+
+      // merging content of base + env
+      tools.logInfo(`Merging ${baseRouteDefsPath} with ${envRouteDefsPath}`);
+
+      const mergedRouteDefs = _.merge(_.keyBy(baseRouteDefsJSON, 'path'), _.keyBy(envRouteDefsJSON, 'path'));
+      const finalRouteDefs = _.values(mergedRouteDefs);
+
+
+      // processing routes
+      let placeHolderContent = '';
+
+      tools.logInfo('Processing routes replacement');
+      finalRouteDefs.forEach((route) => {
+        tools.logInfo(`====> route : ${route.path}`);
+
+        let routeContent = '{\n';
+
+        routeContent += `  path: '${route.path}',\n`;
+        if (route.data) {
+          routeContent += '  data: {\n';
+
+          if (route.data.id) {
+            routeContent += `    id: '${route.data.id}',\n`;
+          }
+          if (route.data.ids) {
+            routeContent += `    ids: '${route.data.ids}',\n`;
+          }
+          if (route.data.featureName) {
+            routeContent += `    featureName: '${route.data.featureName}',\n`;
+          }
+          if (route.data.moduleId) {
+            routeContent += `    moduleId: '${route.data.moduleId}',\n`;
+          }
+          if (route.data.elementTag) {
+            routeContent += `    elementTag: '${route.data.elementTag}',\n`;
+          }
+          if (route.data.iframe) {
+            routeContent += `    iframe: ${route.data.iframe},\n`;
+          }
+          routeContent += '  },\n';
+        }
+        if (route.canActivate) {
+          routeContent += `  canActivate: ${route.canActivate},\n`;
+        }
+        if (route.loadChildren) {
+          routeContent += `  loadChildren: '${route.loadChildren}',\n`
+        }
+        routeContent += '},\n\n';
+
+        placeHolderContent += routeContent;
+
+        tools.logSuccess('======> OK replaced');
+      })
+
+      const placeHolderToken = '// routes-placeholder';
+      routesFileContent = tools.replaceAll(routesFileContent, placeHolderToken, placeHolderContent);
+
+      tools.logInfo('Routes file content replaced : ');
+      console.log(routesFileContent);
+
+      return routesFileContent;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+module.exports.buildRoutes = (project, envTarget, build) => {
+  tools.logTitle('Starting routes replacement');
+
+  let config, routesFile, routesFileContent;
+
+  return Promise.resolve()
+    .then(() => {
+      return getEnvConfig(project, envTarget, build);
+    })
+    .then((envConfig) => {
+      if (!envConfig) {
+        throw 'ENV_CONFIG_NOT_FOUND';
+      }
+      config = envConfig;
+    })
+
+    .then(() => {
+      if (config.routesRemapping) {
+        return getRoutesFile(project);
+
+      } else {
+        return getRoutesFile(project, true);
+      }
+    })
+    .then((outRoutesFile) => {
+      if (!outRoutesFile) {
+        throw 'ROUTES_FILE_NOT_FOUND';
+      }
+      routesFile = outRoutesFile;
+      routesFileContent = tools.getFileContent(routesFile);
+    })
+
+
+    .then(() => {
+      if (config.routesRemapping) {
+        return remapRoutes(config, routesFileContent);
+
+      } else {
+        return replaceRoutes(project, envTarget, build, routesFileContent);
+      }
+    })
+
+    .then((finalRouteFileContent) => {
+      return tools.writeFileContent(routesFile, finalRouteFileContent);
+    })
+    .then(() => {
+      tools.logSuccess();
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+

package/scripts/utils/pre-build/projects.js

@@ -60,7 +60,7 @@ module.exports.preBuild = (project, envTarget, build, configEnvTarget) => {
 
     .then(() => {
       if (project.config && project.appSources && project.appSources.external && project.appSources.remapRoutesByEnvConfig) {
-        return injectionUtils.externals.remapRoutesByEnvConfig(project, envTarget, build);
+        return injectionUtils.routesReplacement.buildRoutes(project, envTarget, build);
       }
     })