@eui/tools 6.10.0 → 6.10.2

package/.prettierrc.json

@@ -11,7 +11,7 @@
     "quoteProps": "as-needed",
     "requirePragma": false,
     "semi": true,
-    "singleQuote": false,
+    "singleQuote": true,
     "tabWidth": 2,
     "trailingComma": "es5",
     "useTabs": false,

package/.version.properties

@@ -1 +1 @@
-6.10.0
+6.10.2

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 6.10.2 (2023-03-27)
+
+##### Chores
+
+* **other:**
+  * add remote-metadata.json extraction during routes replacement - refactored route replacement - MWP-9204 [MWP-9204](https://webgate.ec.europa.eu/CITnet/jira/browse/MWP-9204)  ([d70be286](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/d70be286e52a0f9a4f2be0f3d854d4fe20776870))
+
+* * *
+* * *
+## 6.10.1 (2023-03-24)
+
+##### Bug Fixes
+
+* **other:**
+  * test failing and replace by my-workplace-host project  ([7aa2cee9](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/7aa2cee9d32c21e632cd423c6bbf29deac992f6f))
+  * throw exception if route not found or remote route not found - EUI-7121 [EUI-7121](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-7121)  ([18f5d41e](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/18f5d41e321f2e91c874a9ec8e7b2d08d6a9b4c2))
+
+* * *
+* * *
 ## 6.10.0 (2023-03-24)
 
 ##### New Features

package/package.json

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

package/scripts/csdr/config/projects.test.js

@@ -13,12 +13,12 @@ describe('[csdr/config/config-utils] - getCsdrProject()', () => {
 
 
   it('should return valid project details if project exists', () => {
-    const prj = projects.getCsdrProject('my-workplace');
+    const prj = projects.getCsdrProject('my-workplace-host');
     expect(prj).not.to.be.null;
-    expect(prj.name).to.equal('my-workplace');
-    expect(prj.devopsMetadataFile).to.equal('app-my-workplace-build-metadata.json');
-    expect(prj.devopsEnvsMetadataFile).to.equal('app-my-workplace-envs-metadata.json');
-    expect(prj.devopsVersionsMetadataFile).to.equal('app-my-workplace-versions-metadata.json');
-    expect(prj.devopsHistoryMetadataFile).to.equal('app-my-workplace-history-metadata.json');
+    expect(prj.name).to.equal('my-workplace-host');
+    expect(prj.devopsMetadataFile).to.equal('app-my-workplace-host-build-metadata.json');
+    expect(prj.devopsEnvsMetadataFile).to.equal('app-my-workplace-host-envs-metadata.json');
+    expect(prj.devopsVersionsMetadataFile).to.equal('app-my-workplace-host-versions-metadata.json');
+    expect(prj.devopsHistoryMetadataFile).to.equal('app-my-workplace-host-history-metadata.json');
   })
 });

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

@@ -8,10 +8,73 @@ const configUtils = require('../../../csdr/config/config-utils');
 
 const { debug } = tools.getArgs();
 
+/**
+ *
+ * ROUTES REPLACEMENT
+ *
+ */
+
+/**
+ * Process routes either for playground local environment OR by envTarget at build time,
+ * injects the routesContent generated inside the project/src/app/app.routes.ts file from a base route file and
+ * based on definitions in mywp-host-ui/assets/routes folder definitions as data input
+ *
+ * used by projects pre-build phase
+ *
+ * PUBLIC
+ *
+ * @param {project} project The CSDR project object fetched from csdr global projects config
+ * @param {string} envTarget The build-time environment target provided to target specific routes for specific environment deployments
+ * @param {boolean} build if the script is launched from a release pipeline OR from local CSDR playground environment (false in that case)
+ * @returns {Promise} returns a Promise as it involves async I/O processes
+ */
+module.exports.buildRoutes = (project, envTarget, build) => {
+  tools.logTitle('Starting routes replacement');
+
+  let config, routesFile, routesFileContent;
+
+  const euiVersion = configUtils.projects.getProjectEuiVersion(project);
+
+  return Promise.resolve()
+    .then(() => {
+      return injectRoutesConfig(project, project.externalRoutesSources.routesConfigNpmPkg);
+    })
+
+    .then(() => {
+      return getRoutesFile(project, euiVersion);
+    })
+    .then((outRoutesFile) => {
+      if (!outRoutesFile) {
+        throw 'ROUTES_FILE_NOT_FOUND';
+      }
+      routesFile = outRoutesFile;
+      routesFileContent = tools.getFileContent(routesFile);
+    })
+
+    .then(() => {
+      return processRoutesConfig(project, envTarget, build, routesFile, routesFileContent, euiVersion);
+    })
+
+    .then(() => {
+      tools.logSuccess();
+    })
 
+    .catch((e) => {
+      throw e;
+    });
+};
+
+/**
+ * Get the env target, transform input envTarget to known files suffix or handle local / playground file
+ *
+ * PRIVATE
+ *
+ * @param {string} envTargetIn The build-time environment target provided to target specific routes for specific environment deployments
+ * @param {boolean} build if the script is launched from a release pipeline OR from local CSDR playground environment (false in that case) * @return routeContent the text block transformed from the route object as input
+ * @returns {string} the envTarget transformed
+ */
 const getEnvTarget = (envTargetIn, build) => {
   if (!envTargetIn) {
-
     // check if envTarget has been provided as cli args for stand-alone local build of CSDR apps
     const { envTarget } = tools.getArgs();
 
@@ -30,7 +93,7 @@ const getEnvTarget = (envTargetIn, build) => {
       envTargetFinal = 'test';
     }
 
-  // serve configuration based
+    // serve configuration based
   } else {
     if (envTargetIn.indexOf('local') > -1) {
       envTargetFinal = envTargetIn.replace('-openid', '');
@@ -40,9 +103,17 @@ const getEnvTarget = (envTargetIn, build) => {
   }
 
   return envTargetFinal;
-}
-
-
+};
+
+/**
+ * Get routes file of project
+ *
+ * PRIVATE
+ *
+ * @param {project} project The CSDR project object fetched from csdr global projects config
+ * @param {string} euiVersion the eUI version of the current project used mainly in local CSDR playground environment (format : v.x)
+ * @returns {string} routeContent the text block transformed from the route object as input
+ */
 const getRoutesFile = (project, euiVersion) => {
   tools.logInfo('Getting routes file for replacement');
 
@@ -56,14 +127,18 @@ const getRoutesFile = (project, euiVersion) => {
       let routesFilePath;
       let srcRoutesFilePath;
 
-      if (!project.externalRoutesSources.routesConfigNpmPkg || !project.externalRoutesSources.routesFileSource || !project.externalRoutesSources.routesFilePath) {
+      if (
+        !project.externalRoutesSources.routesConfigNpmPkg ||
+        !project.externalRoutesSources.routesFileSource ||
+        !project.externalRoutesSources.routesFilePath
+      ) {
         tools.logError('project requires externalRoutesSources.routesConfigNpmPkg, routesFileSources and routesFilePath definitions');
         return;
       }
 
       // check if package is locally cloned
       const localPackage = configUtils.packages.getPackages().filter((p) => {
-        return p.npmPkg === project.externalRoutesSources.routesConfigNpmPkg
+        return p.npmPkg === project.externalRoutesSources.routesConfigNpmPkg;
       })[0];
 
       // if local package is found
@@ -73,23 +148,35 @@ const getRoutesFile = (project, euiVersion) => {
         tools.logInfo(`constructing route path with eUI version provided: ${euiVersion}`);
 
         srcRoutesFilePath = path.join(
-          process.cwd(), 'packages', localPackage.name,
-          'assets', euiVersion,
-          project.externalRoutesSources.routesFileSource,
+          process.cwd(),
+          'packages',
+          localPackage.name,
+          'assets',
+          euiVersion,
+          project.externalRoutesSources.routesFileSource
         );
 
-      // if not sources are taken from the npm package def in node_modules
+        // 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.externalRoutesSources.routesConfigNpmPkg.substr(0, project.externalRoutesSources.routesConfigNpmPkg.indexOf('/'));
-        const npmPkgName = project.externalRoutesSources.routesConfigNpmPkg.substr(project.externalRoutesSources.routesConfigNpmPkg.indexOf('/') + 1);
+        const npmPkgScope = project.externalRoutesSources.routesConfigNpmPkg.substr(
+          0,
+          project.externalRoutesSources.routesConfigNpmPkg.indexOf('/')
+        );
+        const npmPkgName = project.externalRoutesSources.routesConfigNpmPkg.substr(
+          project.externalRoutesSources.routesConfigNpmPkg.indexOf('/') + 1
+        );
 
         tools.logInfo(`constructing route path with eUI version provided: ${euiVersion}`);
 
         srcRoutesFilePath = path.join(
-          process.cwd(), 'node_modules', npmPkgScope, npmPkgName,
-          'assets', euiVersion,
-          project.externalRoutesSources.routesFileSource,
+          process.cwd(),
+          'node_modules',
+          npmPkgScope,
+          npmPkgName,
+          'assets',
+          euiVersion,
+          project.externalRoutesSources.routesFileSource
         );
       }
 
@@ -109,9 +196,17 @@ const getRoutesFile = (project, euiVersion) => {
 
     .catch((e) => {
       throw e;
-    })
-}
-
+    });
+};
+
+/**
+ * Replace route object and transform into an Angular / eUI route definition
+ *
+ * PRIVATE
+ *
+ * @param {route} route route object containing the result of the route translated into route props
+ * @returns {string} routeContent the text block transformed from the route object as input
+ */
 const replaceRoute = (route) => {
   let routeContent = '{\n';
 
@@ -143,15 +238,29 @@ const replaceRoute = (route) => {
     routeContent += `  canActivate: ${route.canActivate},\n`;
   }
   if (route.loadChildren) {
-    routeContent += `  ${route.loadChildren},\n`
+    routeContent += `  ${route.loadChildren},\n`;
   }
   routeContent += '},\n\n';
 
   return routeContent;
-}
-
-
-const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVersion) => {
+};
+
+/**
+ * Process the routes config
+ * generates : app.routes.ts project file replacing app.routes-base.ts placehodler / remotes-metadata.json / route-defs-links.json
+ * and feature lib modules in playground local env
+ *
+ * PRIVATE
+ *
+ * @param {project} project The CSDR project object fetched from csdr global projects config
+ * @param {string} envTarget The build-time environment target provided to target specific routes for specific environment deployments
+ * @param {boolean} build if the script is launched from a release pipeline OR from local CSDR playground environment (false in that case)
+ * @param {string} routesFile the route file at project sources target to replace / update
+ * @param {string} routesFileContent the content of the base routes file to inject into the placeholder defined
+ * @param {string} euiVersion the eUI version of the current project used mainly in local CSDR playground environment
+ * @returns {Promise} returns a Promise as it involves async I/O processes
+ */
+const processRoutesConfig = (project, envTarget, build, routesFile, routesFileContent, euiVersion) => {
   return Promise.resolve()
     .then(() => {
       tools.logInfo('Replace routes v2...');
@@ -166,7 +275,6 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
       const euiVersionNumber = euiVersion.split('.')[0];
       const envTargetFinal = getEnvTarget(envTarget, build);
 
-
       // getting the input file definitions of routes for replacements
       // from tokenized template in config -- allowing to control playground vs normal env (when using the MWP HOST for release)
       // format :
@@ -184,8 +292,6 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
 
       tools.logInfo(`Starting replacement of routes based on generated template : ${routeDefsInputFilename}`);
 
-
-
       // Getting input routeDefs entry
 
       const routeDefsInputPath = path.join(projectAssetsPath, routeDefsInputFilename);
@@ -197,18 +303,26 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
 
       const routeDefsInputJSON = require(path.join(routeDefsInputPath));
 
-      const appRoutes = [], appFeatureLibs = [];
+      const appRoutes = [],
+        appFeatureLibs = [],
+        finalRemotesDefs = [];
+
+      // processing each routes found in the routeDefs entry
 
       routeDefsInputJSON.forEach((route) => {
         tools.logInfo(`Processing route : ${route.path}`);
 
-        const defRoute = routeDefsBaseJSON.filter(r => r.path === route.path)[0];
+        const defRoute = routeDefsBaseJSON.filter((r) => r.path === route.path)[0];
         if (!defRoute) {
-          tools.logError('==>route not found');
-
+          tools.logError('route not found for: ');
+          console.log(route);
+          throw 'ROUTE_NOT_FOUND';
         } else {
           let loadChildrenGenerated;
 
+          // in case of a lazy route, the route is generated from a import/export feature lib module TS file
+          // those files are also generated based on the route "lazyDefs" data definition
+
           if (route.lazy) {
             const scopeName = defRoute.lazyLoadDef.npmPkg.split('/')[0].substr(1);
             const pkgName = defRoute.lazyLoadDef.npmPkg.split('/')[1];
@@ -223,9 +337,10 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
             appFeatureLibs.push({
               filename: `${lazyFeatureLibName}.ts`,
               npmPkg: defRoute.lazyLoadDef.npmPkg,
-              moduleName: defRoute.lazyLoadDef.moduleName
+              moduleName: defRoute.lazyLoadDef.moduleName,
             });
 
+            // if the route is a remote, the elementLoader is then used as a default feature module loaded
           } else {
             if (euiVersion === '10.x') {
               loadChildrenGenerated = 'loadChildren: "./features/element-loader.module#ElementLoaderModule"';
@@ -234,38 +349,61 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
             }
           }
 
+          // we define the route item definition, that will be injected in the project app.routes source
           const newAppRoute = {
             path: defRoute.path,
             loadChildren: loadChildrenGenerated,
-            data: {}
+            data: {},
           };
 
+          // in the case the route is auth guarded, we attach the defition of the auth parameters
           if (defRoute.authMetadata) {
             newAppRoute.data.id = defRoute.authMetadata.id;
             newAppRoute.data.ids = defRoute.authMetadata.ids;
             newAppRoute.canActivate = defRoute.authMetadata.canActivate;
           }
 
+          // in case of a remote, the "remoteDefs" data entry are processed
+          // in case no remote corresponds to a remote path defined in the definitions, we throw an error and we stop the
+          // script to avoid bad route data / or partial routes data generated
           if (route.remote) {
-            const remoteDef = defRoute.remoteDefs.filter((r) => {
-              return r.euiVersion === route.euiVersion
-            })[0];
+            let remoteDef;
+            try {
+              remoteDef = defRoute.remoteDefs.filter((r) => {
+                return r.euiVersion === route.euiVersion;
+              })[0];
+            } catch {
+              tools.logError('Remote route not found for: ');
+              console.log(route);
+              throw 'REMOTE_ROUTE_DEF_NOT_FOUND';
+            }
+
             if (remoteDef) {
               newAppRoute.data.moduleId = remoteDef.moduleId;
               newAppRoute.data.elementTag = remoteDef.elementTag;
               newAppRoute.data.iframe = remoteDef.iframe;
-
             } else {
               tools.logError('Remote route not found for: ');
               console.log(route);
               throw 'REMOTE_ROUTE_DEF_NOT_FOUND';
             }
+
+            finalRemotesDefs.push(remoteDef.moduleId);
           }
 
           appRoutes.push(newAppRoute);
         }
-      })
+      });
 
+      // writing final remotes metadata file base on routes definitions (loaded at runtime by the app for gathering the list of remotes)
+
+      if (finalRemotesDefs.length > 0) {
+        const finalRemotesDefsFile = path.join(projectAssetsPath, 'remotes-metadata.json');
+
+        tools.logInfo(`Generating ${finalRemotesDefsFile}`);
+
+        tools.writeJsonFileSync(finalRemotesDefsFile, finalRemotesDefs);
+      }
 
       // processing creation of features lib modules entries
 
@@ -291,8 +429,7 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
         tools.writeFileContent(featureLibPath, featureLibDef);
       });
 
-
-      // processing links generation
+      // processing links generation : generates a routes-defs-links.json based on the routes-defs-base-links.json definitions
 
       const routeDefsBaseLinksFileName = 'route-defs-base-links.json';
       const routeDefsBaseLinksJSON = require(path.join(projectAssetsPath, routeDefsBaseLinksFileName));
@@ -316,7 +453,10 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
         }
 
         return routeDef;
-      }
+      };
+
+      // inner method for checking based on the "allowedEnvs" option provided on the links definition if the link has to be added
+      // to the links list
 
       const isLinkAllowed = (link) => {
         // allow all link for playground - local env
@@ -334,7 +474,9 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
         } else {
           return true;
         }
-      }
+      };
+
+      // processing each link and matching route from routes base data definitions
 
       const linksGenerated = [];
 
@@ -343,7 +485,7 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
 
         if (link.parentId) {
           if (isLinkAllowed(link)) {
-            newLink = { ...link};
+            newLink = { ...link };
             newLink.children = [];
 
             link.children.forEach((subLink) => {
@@ -354,9 +496,8 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
                   newLink.children.push(defRoute);
                 }
               }
-            })
+            });
           }
-
         } else {
           if (isLinkAllowed(link)) {
             const defRoute = getRouteMenuDef(link);
@@ -366,6 +507,10 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
             } else {
               newLink = link;
             }
+
+            if (link.alwaysDisplayed) {
+              newLink.alwaysDisplayed = true;
+            }
           }
         }
 
@@ -383,7 +528,6 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
 
       tools.writeJsonFileSync(path.join(projectAssetsPath, 'route-defs-links.json'), linksGenerated);
 
-
       // getting routes content for replacement
 
       tools.logInfo('Processing routes replacement');
@@ -402,21 +546,28 @@ const processRoutesConfig = (project, envTarget, build, routesFileContent, euiVe
         console.log(routesFileContent);
       }
 
-      return routesFileContent;
+      // writing final routes content into project sources
+      tools.writeFileContent(routesFile, routesFileContent);
     })
 
     .catch((e) => {
       throw e;
-    })
-}
-
-
-
-
+    });
+};
+
+/**
+ * Inject the routes config assets from mywp-host-ui / assets / routes to virtual project assets folder
+ *
+ * PRIVATE
+ *
+ * @param {project} project The CSDR project object fetched from csdr global projects config
+ * @param {string} npmPkg The npm package dependency containing the routes definition (for MyWorkplace : mywp-host-ui => @mywp/host)
+ * @returns undefined
+ */
 const injectRoutesConfig = (project, npmPkg) => {
   // check if package is locally cloned
   const localPackage = configUtils.packages.getPackages().filter((p) => {
-    return p.npmPkg === npmPkg
+    return p.npmPkg === npmPkg;
   })[0];
 
   var pkgAssetsPath;
@@ -426,7 +577,7 @@ const injectRoutesConfig = (project, npmPkg) => {
   if (localPackage) {
     pkgAssetsPath = path.join(process.cwd(), 'packages', localPackage.name, 'assets');
 
-  // if not sources are taken from the npm package def in node_modules
+    // if not sources are taken from the npm package def in node_modules
   } else {
     const npmPkgScope = npmPkg.substr(0, npmPkg.indexOf('/'));
     const npmPkgName = npmPkg.substr(npmPkg.indexOf('/') + 1);
@@ -442,48 +593,4 @@ const injectRoutesConfig = (project, npmPkg) => {
 
   tools.logInfo(`${routesConfigPath} - injecting in ${projectAssetsPath}`);
   tools.copydir(routesConfigPath, projectAssetsPath);
-}
-
-
-
-
-module.exports.buildRoutes = (project, envTarget, build) => {
-  tools.logTitle('Starting routes replacement');
-
-  let config, routesFile, routesFileContent;
-
-  const euiVersion = configUtils.projects.getProjectEuiVersion(project);
-
-  return Promise.resolve()
-    .then(() => {
-      return injectRoutesConfig(project, project.externalRoutesSources.routesConfigNpmPkg);
-    })
-
-    .then(() => {
-      return getRoutesFile(project, euiVersion);
-    })
-    .then((outRoutesFile) => {
-      if (!outRoutesFile) {
-        throw 'ROUTES_FILE_NOT_FOUND';
-      }
-      routesFile = outRoutesFile;
-      routesFileContent = tools.getFileContent(routesFile);
-    })
-
-    .then(() => {
-      return processRoutesConfig(project, envTarget, build, routesFileContent, euiVersion);
-    })
-
-    .then((finalRouteFileContent) => {
-      return tools.writeFileContent(routesFile, finalRouteFileContent);
-    })
-
-    .then(() => {
-      tools.logSuccess();
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
+};