@eui/tools 5.0.0-rc.9 → 5.1.0

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

@@ -0,0 +1,322 @@
+'use strict';
+
+const path = require('path');
+const _ = require('lodash');
+
+const tools = require('../../tools');
+const configUtils = require('../../../csdr/config/config-utils');
+
+
+const getEnvTarget = (envTarget, build) => {
+  if (!envTarget) {
+    throw 'ENV_TARGET_NOT_FOUND';
+  }
+
+  let envTargetFinal = envTarget.toLowerCase();
+
+  if (build) {
+    // dirty fix as openid files do not respect envTarget names
+    if (envTargetFinal === 'tst') {
+      envTargetFinal = 'test';
+    }
+
+  // serve configuration based
+  } else {
+    if (envTarget.indexOf('local') > -1) {
+      envTargetFinal = envTarget.replace('-openid', '');
+    } else {
+      envTargetFinal = 'local-' + envTargetFinal;
+    }
+  }
+
+  return envTargetFinal;
+}
+
+
+
+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');
+      const envTargetFinal = getEnvTarget(envTarget, build);
+      const configFile = path.join(projectAssetsPath, 'openid-login-config.' + envTargetFinal + '.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 = [];
+      const envTargetFinal = getEnvTarget(envTarget, build);
+
+      envRouteDefsPath = path.join(projectAssetsPath, 'route-defs.' + envTargetFinal + '.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/injection/skeletons.js

@@ -46,14 +46,20 @@ module.exports.injectCsdrSkeletonEuiShowcaseSources = (project) => {
 }
 
 
-module.exports.injectCsdrFullSkeletonSources = (project) => {
+module.exports.injectCsdrFullSkeletonSources = (project, euiVersion) => {
 
-  tools.logInfo(`Injecting CSDR full skeleton sources for : ${project.name}`);
+  tools.logInfo(`Injecting CSDR full skeleton sources for : ${project.name} - eUI version : ${euiVersion}`);
 
   return Promise.resolve()
     .then(() => {
       // copying skeleton sources
-      tools.copydir(path.join(__dirname, 'app-sources-full-skeleton'), project.folder, false);
+      if (euiVersion === '13.x') {
+        tools.copydir(path.join(__dirname, 'app-sources-full-skeleton-eui13'), project.folder, false);
+      } else if (euiVersion === '14.x') {
+        tools.copydir(path.join(__dirname, 'app-sources-full-skeleton-eui14'), project.folder, false);
+      } else {
+        tools.copydir(path.join(__dirname, 'app-sources-full-skeleton'), project.folder, false);
+      }
 
       // renaming tst.ts as it's conflicting with Jest... (TODO)
       tools.move(path.join(project.folder, 'src', '_generated', 'tst.ts'), path.join(project.folder, 'src', '_generated', 'test.ts'));

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

@@ -9,10 +9,10 @@ const translationUtils = require('./translations/translation-utils');
 
 const configUtils = require('../../csdr/config/config-utils');
 
-let { configEnvTarget, openid } = tools.getArgs();
+let { openid } = tools.getArgs();
 
 
-module.exports.preBuild = (project, envTarget, build) => {
+module.exports.preBuild = (project, envTarget, build, configEnvTarget) => {
 
   return Promise.resolve()
 
@@ -60,7 +60,7 @@ module.exports.preBuild = (project, envTarget, build) => {
 
     .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);
       }
     })
 
@@ -73,7 +73,13 @@ module.exports.preBuild = (project, envTarget, build) => {
         return injectionUtils.skeletons.injectCsdrSkeletonEuiShowcaseSources(project);
 
       } else if (project.csdrFullSkeleton) {
-        return injectionUtils.skeletons.injectCsdrFullSkeletonSources(project);
+        if (project.build && project.build.euiVersion === '13.x') {
+          return injectionUtils.skeletons.injectCsdrFullSkeletonSources(project, '13.x');
+        } else if (project.build && project.build.euiVersion === '14.x') {
+          return injectionUtils.skeletons.injectCsdrFullSkeletonSources(project, '14.x');
+        } else {
+          return injectionUtils.skeletons.injectCsdrFullSkeletonSources(project);
+        }
       }
     })
 
@@ -84,10 +90,6 @@ module.exports.preBuild = (project, envTarget, build) => {
         tools.logInfo('Executing scripts files replacement for openId Connect');
 
         let rootTargetFolder = 'src';
-        // if (build) {
-        //   rootTargetFolder = 'dist';
-        // }
-
         tools.logInfo(`Copying node_modules/oidc-client/dist/oidc-client.min.js to ${rootTargetFolder}/assets/oidc-client.min.js`);
         tools.copy(
           path.join(process.cwd(), 'node_modules/oidc-client/dist/oidc-client.min.js'),
@@ -111,7 +113,7 @@ module.exports.preBuild = (project, envTarget, build) => {
       }
 
       if (configEnvTarget) {
-        return this.injectAppConfig(project, configEnvTarget, build);
+        return this.injectAppConfig(project, configEnvTarget);
       }
     })
 
@@ -122,7 +124,7 @@ module.exports.preBuild = (project, envTarget, build) => {
 
 
 
-module.exports.injectAppConfig = (project, configEnvTarget, build) => {
+module.exports.injectAppConfig = (project, configEnvTarget) => {
   return Promise.resolve()
     .then(() => {
       tools.logInfo(`Executing configuration replacement for : ${configEnvTarget} environment`);
@@ -136,12 +138,15 @@ module.exports.injectAppConfig = (project, configEnvTarget, build) => {
       }
 
       let rootTargetFolder = 'src';
-      // if (build) {
-      //   rootTargetFolder = 'dist';
-      // }
+      let replacedFile;
 
-      tools.logInfo(`Replacing default ${rootTargetFolder}/assets/openid-login-config.json file by ${envFilePath} content`);
-      tools.copy(envFilePath, path.join(project.paths.angularPath, `${rootTargetFolder}/assets/openid-login-config.json`));
+      if ((project.build && project.build.openid) || openid) {
+        replacedFile = `${rootTargetFolder}/assets/openid-login-config.json`;
+      } else {
+        replacedFile = `${rootTargetFolder}/assets/env-json-config.json`;
+      }
+      tools.logInfo(`Replacing default ${replacedFile} file by ${envFilePath} content`);
+      tools.copy(envFilePath, path.join(project.paths.angularPath, `${replacedFile}`));
 
       tools.logSuccess();
     })

package/scripts/utils/pre-build/translations/elements.js

@@ -51,17 +51,17 @@ module.exports.generate = (inputScopes = '', inputPkg) => {
           tools.logInfo(`Adding packages from scope "${scope}"`);
           const scopePath = path.resolve(nmPath, scope);
           if (tools.isDirExists(scopePath)) {
-            let files = fs.readdirSync(scopePath).map(pkg => path.resolve(nmPath,  `${scope}/${pkg}`))
+            let files = fs.readdirSync(scopePath).map((pkg) => {
+              return {
+                name: pkg,
+                scope: scope,
+                folder: path.resolve(nmPath,  `${scope}/${pkg}`)
+              }
+            });
             packages = [...packages, ...files];
           }
       });
 
-      // configUtils.packages.getPackages().forEach((pkg) => {
-      //   const localPath = configUtils.packages.getPackagePaths(pkg).pkgRootDirectory;
-      //   console.log(localPath);
-      //   packages.push(localPath);
-      // })
-
       tools.logInfo(`langs: ${langs}`);
       tools.logInfo(`dest folder: ${destFolder}`);
       tools.logInfo(`total packages: ${packages.length}`);
@@ -69,7 +69,7 @@ module.exports.generate = (inputScopes = '', inputPkg) => {
     })
 
     .then(() => {
-        if (!fs.existsSync(destFolder)) {
+        if (!fs.existsSync(destFolder) && !dryRun) {
           fs.mkdirSync(destFolder);
         }
 
@@ -82,9 +82,19 @@ module.exports.generate = (inputScopes = '', inputPkg) => {
 
             // Add module translations
             packages.forEach((pkg) => {
-                // console.log('...adding translation from module "' + pkg + '".');
-                file = path.join(pkg, `assets/i18n/${lang}.json`);
-                addTranslation(file, lang)
+                let baseI18nPath = 'i18n';
+                if (pkg.scope === '@eui') {
+                  baseI18nPath = 'i18n-eui';
+                }
+                file = path.join(pkg.folder, `assets/${baseI18nPath}/${lang}.json`);
+
+                tools.logInfo(`Adding translations from ${pkg.folder}`);
+                if (tools.isFileExists(file)) {
+                  tools.logInfo(`${file} found...adding`);
+                  addTranslation(file, lang)
+                } else {
+                  tools.logInfo(`${file} not found...skipping`);
+                }
             });
 
             // Write final file

package/scripts/utils/serve/app.js

@@ -10,7 +10,7 @@ const configUtils = require('../../csdr/config/config-utils');
 
 module.exports.serve = () => {
 
-  let { configuration, baseHref, host, proxyConfig, maxSpaceSize, port, disableHostCheck, open } = tools.getArgs();
+  let { configuration, baseHref, host, proxyConfig, maxSpaceSize, port, disableHostCheck, open, debug, configEnvTarget } = tools.getArgs();
 
   const prj = configUtils.projects.getProject();
 
@@ -24,18 +24,21 @@ module.exports.serve = () => {
 
   const ng = path.resolve(process.cwd(), 'node_modules', '@angular', 'cli', 'bin', 'ng');
 
-  console.log('Provided arguments:\n');
+  tools.logInfo('Provided arguments:\n');
   console.log(`configuration=${configuration}, baseHref=${baseHref}, host=${host}`);
 
 
   return Promise.resolve()
     .then(() => {
       tools.logTitle(`Serving application : ${prj.name}...`);
-      console.log(prj);
+
+      if (debug) {
+        console.log(prj);
+      }
     })
 
     .then(() => {
-      return preBuildUtils.projects.preBuild(prj, configuration, false);
+      return preBuildUtils.projects.preBuild(prj, configuration, false, configEnvTarget);
     })
 
 

package/scripts/utils/test/test-utils.js

@@ -9,7 +9,7 @@ const tools = require('../tools');
 const configUtils = require('../../csdr/config/config-utils');
 
 // FETCH ARGS
-const { watch, skipCoverage } = tools.getArgs();
+const { watch, skipCoverage, timeout, build } = tools.getArgs();
 
 
 
@@ -84,3 +84,41 @@ module.exports.runJest = (pkg) => {
       throw e;
     })
 }
+
+
+module.exports.runMocha = (pkg) => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logTitle(`Executing Mocha test for pkg: ${pkg.name}`);
+
+      // set jest binary
+      const mocha = path.resolve(process.cwd(), 'node_modules', 'mocha', 'bin', 'mocha');
+      const nyc = path.resolve(process.cwd(), 'node_modules', 'nyc', 'bin', 'nyc');
+
+      // default arguments
+      let args;
+
+      if (!skipCoverage && !build) {
+        args = [nyc, '--reporter=text', mocha, pkg.paths.pkgFromRoot +  '/**/*.test.js'];
+      } else {
+        args = [mocha, pkg.paths.pkgFromRoot +  '/**/*.test.js'];
+      }
+      if (watch) {
+        args.push('--watch');
+      }
+      if (timeout) {
+        args.push(`--timeout ${timeout}`);
+      } else {
+        args.push('--timeout 5000');
+      }
+
+      return execa('node', args, { cwd: process.cwd(), stdio: 'inherit' });
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+