@eui/tools 5.3.72 → 5.3.73

package/.version.properties

@@ -1 +1 @@
-5.3.72
+5.3.73

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 5.3.73 (2022-10-11)
+
+##### Chores
+
+* **other:**
+  * allow array of app sources injection and overrides - MWP-8868 [MWP-8868](https://webgate.ec.europa.eu/CITnet/jira/browse/MWP-8868)  ([55ae46fc](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/55ae46fcaea7263983452b9da90c56545561238c))
+
+* * *
+* * *
 ## 5.3.72 (2022-10-07)
 
 ##### Chores

package/package.json

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

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

@@ -64,89 +64,119 @@ module.exports.injectExternalFeatures = (project) => {
 }
 
 
+
+const injectExternalAppSourcesCore = (project, build = false, injectedNpmPkg, injectedFolder) => {
+
+  tools.logInfo(`Injecting : ${injectedNpmPkg} / ${injectedFolder}`);
+
+  return Promise.resolve()
+  .then(() => {
+    // check if package is locally cloned
+    const localPackage = configUtils.packages.getPackages().filter((p) => {
+      return p.npmPkg === injectedNpmPkg
+    })[0];
+
+    let appSourcesSrcPath;
+    const projectSrcPath = path.join(process.cwd(), project.folder, 'src');
+
+    // if local package is found
+    if (localPackage) {
+      tools.logInfo('local project found, copying from local');
+      appSourcesSrcPath = path.join(process.cwd(), 'packages', localPackage.name, injectedFolder);
+
+    // if not sources are taken from the npm package def in node_modules
+    } else {
+      tools.logInfo('remote project found, copying from remote');
+      const npmPkgScope = injectedNpmPkg.substr(0, injectedNpmPkg.indexOf('/'));
+      const npmPkgName = injectedNpmPkg.substr(injectedNpmPkg.indexOf('/') + 1);
+
+      appSourcesSrcPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, injectedFolder);
+    }
+
+    if (!tools.isDirExists(appSourcesSrcPath)) {
+      tools.logWarning(`External sources location : ${appSourcesSrcPath} cannot be found in node_modules`);
+      throw new Error('External sources not found');
+
+    } else {
+
+      return Promise.resolve()
+        .then(() => {
+          tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
+          return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
+        })
+        .catch((e) => {
+          throw e;
+        })
+    }
+  })
+
+  .catch((e) => {
+    throw e;
+  })
+}
+
+
+
 module.exports.injectExternalAppSources = (project, build = false) => {
 
   tools.logTitle(`Injecting project external application sources for : ${project.name}`);
 
   return Promise.resolve()
     .then(() => {
-      if (!project.appSources) {
+      if (!build) {
+        // removing previously injected content, except assets
+        const projectSrcPath = path.join(process.cwd(), project.folder, 'src');
+        const projectSrcAppPath = path.join(projectSrcPath, 'app');
+        const projectSrcConfigPath = path.join(projectSrcPath, 'config');
+        const projectSrcEnvironmentsPath = path.join(projectSrcPath, 'environments');
+
+        return Promise.resolve()
+          .then(() => {
+            tools.logInfo(`Removing ${projectSrcAppPath} content`);
+            return tools.rimraf(projectSrcAppPath);
+          })
+          .then(() => {
+            tools.logInfo(`Removing ${projectSrcConfigPath} content`);
+            return tools.rimraf(projectSrcConfigPath);
+          })
+          .then(() => {
+            tools.logInfo(`Removing ${projectSrcEnvironmentsPath} content`);
+            return tools.rimraf(projectSrcEnvironmentsPath);
+          })
+          .catch((e) => {
+            throw e;
+          })
+      }
+    })
+    .then(() => {
+      if (!project.externalSources) {
         tools.logInfo('No external app sources setup...skipping');
         return;
       }
 
-      if (!project.appSources.npmPkg || !project.appSources.folder) {
-        return tools.logWarning('External appSources use requires a source [npmPkg] and a [folder] declared');
-
+      // in case of multiple injection are defined, we promise loop on each injection
+      if (Array.isArray(project.externalSources)) {
+        return Promise.resolve().then(() => {
+          return project.externalSources.reduce((promise, appSource) => {
+            return promise.then(() => (
+              injectExternalAppSourcesCore(project, build, appSource.npmPkg, appSource.folder)
+            ));
+          }, Promise.resolve());
+        })
+
+      // if only one injection externalSources is defined
       } else {
-        // check if package is locally cloned
-        const localPackage = configUtils.packages.getPackages().filter((p) => {
-          return p.npmPkg === project.appSources.npmPkg
-        })[0];
-
-        let appSourcesSrcPath;
-        const projectSrcPath = path.join(process.cwd(), project.folder, 'src');
-
-        // if local package is found
-        if (localPackage) {
-          tools.logInfo('local project found, copying from local');
-          appSourcesSrcPath = path.join(process.cwd(), 'packages', localPackage.name, project.appSources.folder);
-
-        // if not sources are taken from the npm package def in node_modules
-        } else {
-          tools.logInfo('remote project found, copying from remote');
-          const npmPkgScope = project.appSources.npmPkg.substr(0, project.appSources.npmPkg.indexOf('/'));
-          const npmPkgName = project.appSources.npmPkg.substr(project.appSources.npmPkg.indexOf('/') + 1);
-
-          appSourcesSrcPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, project.appSources.folder);
-        }
-
-        if (!tools.isDirExists(appSourcesSrcPath)) {
-          tools.logWarning(`External features location : ${appSourcesSrcPath} cannot be found in node_modules`);
-          throw new Error('External features not found');
+        if (!project.externalSources.npmPkg || !project.externalSources.folder) {
+          return tools.logWarning('External externalSources use requires a source [npmPkg] and a [folder] declared');
 
         } else {
-
-          return Promise.resolve()
-            .then(() => {
-              if (!build) {
-                // removing previously injected content, except assets
-                const projectSrcAppPath = path.join(projectSrcPath, 'app');
-                const projectSrcConfigPath = path.join(projectSrcPath, 'config');
-                const projectSrcEnvironmentsPath = path.join(projectSrcPath, 'environments');
-
-                return Promise.resolve()
-                  .then(() => {
-                    tools.logInfo(`Removing ${projectSrcAppPath} content`);
-                    return tools.rimraf(projectSrcAppPath);
-                  })
-                  .then(() => {
-                    tools.logInfo(`Removing ${projectSrcConfigPath} content`);
-                    return tools.rimraf(projectSrcConfigPath);
-                  })
-                  .then(() => {
-                    tools.logInfo(`Removing ${projectSrcEnvironmentsPath} content`);
-                    return tools.rimraf(projectSrcEnvironmentsPath);
-                  })
-                  .catch((e) => {
-                    throw e;
-                  })
-              }
-            })
-            .then(() => {
-              tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
-              return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
-            })
-            .catch((e) => {
-              throw e;
-            })
+          return injectExternalAppSourcesCore(project, build, project.externalSources.npmPkg, project.externalSources.folder);
         }
       }
     })
     .catch((e) => {
       throw e;
     })
-
 }
 
 

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

@@ -6,6 +6,10 @@ const _ = require('lodash');
 const tools = require('../../tools');
 const configUtils = require('../../../csdr/config/config-utils');
 
+// const { subRoutes, debug } = tools.getArgs();
+const { debug } = tools.getArgs();
+
+
 
 const getEnvTarget = (envTargetIn, build) => {
   if (!envTargetIn) {
@@ -71,39 +75,39 @@ const getRoutesFile = (project) => {
 
   return Promise.resolve()
     .then(() => {
-      if (!project.appSources) {
-        tools.logError('project requires appSources definition');
+      if (!project.externalRoutesSources) {
+        tools.logError('project requires externalRoutesSources definition');
         return;
       }
 
       let routesFilePath;
       let srcRoutesFilePath;
 
-      if (!project.appSources.routesFileNpmPkg || !project.appSources.routesFileSource || !project.appSources.routesFilePath) {
-        tools.logError('project requires appSources.routesFileNpmPkg, routesFileSources and routesFilePath definitions');
+      if (!project.externalRoutesSources.routesFileNpmPkg || !project.externalRoutesSources.routesFileSource || !project.externalRoutesSources.routesFilePath) {
+        tools.logError('project requires externalRoutesSources.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
+        return p.npmPkg === project.externalRoutesSources.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);
+        srcRoutesFilePath = path.join(process.cwd(), 'packages', localPackage.name, project.externalRoutesSources.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);
+        const npmPkgScope = project.externalRoutesSources.routesFileNpmPkg.substr(0, project.externalRoutesSources.routesFileNpmPkg.indexOf('/'));
+        const npmPkgName = project.externalRoutesSources.routesFileNpmPkg.substr(project.externalRoutesSources.routesFileNpmPkg.indexOf('/') + 1);
 
-        srcRoutesFilePath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, project.appSources.routesFileSource);
+        srcRoutesFilePath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, project.externalRoutesSources.routesFileSource);
       }
 
-      routesFilePath = path.join(project.paths.rootPath, project.appSources.routesFilePath);
+      routesFilePath = path.join(project.paths.rootPath, project.externalRoutesSources.routesFilePath);
 
       // copy source file to project destination
       tools.copy(srcRoutesFilePath, routesFilePath);
@@ -130,8 +134,8 @@ const replaceRoutes = (project, envTarget, build, routesFileContent) => {
       // getting base route defs content
       const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
       let routeDefsBaseFilename = 'route-defs-base.json';
-      if (project.appSources.routesBaseFilename) {
-        routeDefsBaseFilename = project.appSources.routesBaseFilename;
+      if (project.externalRoutesSources.routesBaseFilename) {
+        routeDefsBaseFilename = project.externalRoutesSources.routesBaseFilename;
       }
       const baseRouteDefsPath = path.join(projectAssetsPath, routeDefsBaseFilename);
 
@@ -160,13 +164,22 @@ const replaceRoutes = (project, envTarget, build, routesFileContent) => {
       const mergedRouteDefs = _.merge(_.keyBy(baseRouteDefsJSON, 'path'), _.keyBy(envRouteDefsJSON, 'path'));
       const finalRouteDefs = _.values(mergedRouteDefs);
 
+      // getting subRoutes if passed as arguments
+      // let subRoutesArray;
+
+      // if (subRoutes) {
+      //   subRoutesArray = subRoutes.split(',');
+
+      //   tools.logInfo('subRoutes arguments foound : ');
+      //   tools.logInfo(subRoutesArray);
+      // }
 
       // processing routes
       let placeHolderContent = '';
 
       tools.logInfo('Processing routes replacement');
       finalRouteDefs.forEach((route) => {
-        tools.logInfo(`====> route : ${route.path}`);
+        if (debug) tools.logInfo(`====> route : ${route.path}`);
 
         let routeContent = '{\n';
 
@@ -204,14 +217,24 @@ const replaceRoutes = (project, envTarget, build, routesFileContent) => {
 
         placeHolderContent += routeContent;
 
-        tools.logSuccess('======> OK replaced');
+        // if (subRoutesArray) {
+        //   if (subRoutesArray.includes(route.path)) {
+        //     placeHolderContent += routeContent;
+        //   }
+        // } else {
+        //   placeHolderContent += routeContent;
+        // }
+
+        if (debug) tools.logSuccess('======> OK replaced');
       })
 
       const placeHolderToken = '// routes-placeholder';
       routesFileContent = tools.replaceAll(routesFileContent, placeHolderToken, placeHolderContent);
 
-      tools.logInfo('Routes file content replaced : ');
-      console.log(routesFileContent);
+      if (debug) {
+        tools.logInfo('Routes file content replaced : ');
+        console.log(routesFileContent);
+      }
 
       return routesFileContent;
     })

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

@@ -29,7 +29,7 @@ module.exports.preBuild = (project, envTarget, build, configEnvTarget) => {
 
     // inject external app sources declaration
     .then(() => {
-      if (project.appSources && project.appSources.external) {
+      if (project.externalSources) {
         return injectionUtils.externals.injectExternalAppSources(project, build);
       }
     })
@@ -62,7 +62,7 @@ module.exports.preBuild = (project, envTarget, build, configEnvTarget) => {
 
 
     .then(() => {
-      if (project.config && project.appSources && project.appSources.external && project.appSources.remapRoutesByEnvConfig) {
+      if (project.config && project.externalRoutesSources) {
         return injectionUtils.routesReplacement.buildRoutes(project, envTarget, build);
       }
     })