@eui/tools 5.0.0-rc.1 → 5.0.0-rc.13

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(() => {
@@ -49,6 +49,9 @@ module.exports.injectExternalFeatures = (project) => {
           throw new Error('External features not found');
 
         } else {
+          tools.logInfo(`Removing ${projectSrcPath} content`);
+          tools.rmdirFull(projectSrcPath, false);
+
           tools.logInfo(`${featuresSrcPath} injecting in ${projectSrcPath}`);
           return tools.copydir(featuresSrcPath, projectSrcPath, true);
         }
@@ -63,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(() => {
@@ -103,8 +106,19 @@ module.exports.injectExternalAppSources = (project) => {
           throw new Error('External features not found');
 
         } else {
-          tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
-          return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
+          tools.logInfo(`Removing ${projectSrcPath} content`);
+
+          return Promise.resolve()
+            .then(() => {
+              return tools.rmdirFull(projectSrcPath, false);
+            })
+            .then(() => {
+              tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
+              return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
+            })
+            .catch((e) => {
+              throw e;
+            })
         }
       }
     })
@@ -115,94 +129,78 @@ module.exports.injectExternalAppSources = (project) => {
 }
 
 
-module.exports.injectExternalMock = (project) => {
+module.exports.injectElementExternalSources = (pkg) => {
 
-  tools.logInfo(`Injecting project external mock for : ${project.name}`);
+  tools.logTitle(`Injecting package external sources for : ${pkg.name}`);
 
   return Promise.resolve()
     .then(() => {
-      if (!(project.mock && project.mock.external)) {
-        tools.logInfo('No external mock setup...skipping')
+      if (!pkg.externalSources) {
+        tools.logInfo('No external sources setup...skipping');
+        return;
+      }
+
+      if (!pkg.externalSources.npmPkg || !pkg.externalSources.folder) {
+        return tools.logWarning('External sources use requires a source [npmPkg] and a [folder] declared');
 
       } else {
-        return gitUtils.cloneRepo(project.mock.repository, project.mock.folder);
-      }
-    })
+        // check if package is locally cloned
+        const localPackage = configUtils.packages.getPackages().filter((p) => {
+          return p.npmPkg === pkg.externalSources.npmPkg
+        })[0];
 
-    .catch((e) => {
-      throw e;
-    })
-}
+        let externalSourcesSrcPath;
+        const pkgSrcPath = path.join(pkg.paths.pkgRootDirectory, 'src');
 
-module.exports.remapRoutesByEnvConfig = (project, envTarget, build) => {
-  tools.logInfo(`Remapping routes by env config for ${envTarget}`);
+        // if local package is found
+        if (localPackage) {
+          tools.logInfo('local pkg found, copying from local');
+          externalSourcesSrcPath = path.join(process.cwd(), 'packages', localPackage.name, pkg.externalSources.folder);
 
-  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';
+        // if not sources are taken from the npm package def in node_modules
+        } else {
+          tools.logInfo('remote pkg found, copying from remote');
+          const npmPkgScope = pkg.externalSources.npmPkg.substr(0, pkg.externalSources.npmPkg.indexOf('/'));
+          const npmPkgName = pkg.externalSources.npmPkg.substr(pkg.externalSources.npmPkg.indexOf('/') + 1);
+
+          externalSourcesSrcPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, pkg.externalSources.folder);
         }
-        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');
+        if (!tools.isDirExists(externalSourcesSrcPath)) {
+          tools.logWarning(`External sources location : ${externalSourcesSrcPath} cannot be found in node_modules`);
+          throw new Error('External sources not found');
+
         } else {
-          configFile = path.join(projectAssetsPath, 'openid-login-config.local-' + envTarget + '.json');
+          if (tools.isDirExists(pkgSrcPath)) {
+            tools.logInfo(`Removing ${pkgSrcPath} content`);
+            tools.rmdirFull(pkgSrcPath, false);
+          }
+
+          tools.logInfo(`${externalSourcesSrcPath} injecting in ${pkgSrcPath}`);
+          return tools.copydir(externalSourcesSrcPath, pkgSrcPath, true);
         }
       }
+    })
 
-      tools.logInfo(`checking ${configFile}`);
-      if (!tools.isFileExists(configFile)) {
-        tools.logError(`config file for ${envTarget} do not exists`);
-        return;
-      }
+    .catch((e) => {
+      throw e;
+    })
+}
 
-      // 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 apps 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;
-      }
+module.exports.injectExternalMock = (project) => {
 
-      // get routes file content and replace tokens
-      let routesFileContent = tools.getFileContent(routesFilePath);
-      routesRemapping.forEach((route) => {
-        tools.logInfo(`checking replacement for : ${JSON.stringify(route)}`);
-        // const tokenToSearch = `@${route.featureModule}.routeModuleDef@`;
-        const tokenToSearch = `./features/${route.featureModule}-lib.module#Module`;
-        if (routesFileContent.indexOf(tokenToSearch) > -1) {
-          tools.logInfo(`token ${tokenToSearch} found...replacing`);
-          routesFileContent = tools.replaceAll(routesFileContent, tokenToSearch, route.routeModuleDef);
-        }
-      })
-      return tools.writeFileContent(routesFilePath, routesFileContent);
-    })
+  tools.logTitle(`Injecting project external mock for : ${project.name}`);
+
+  return Promise.resolve()
     .then(() => {
-      tools.logSuccess();
+      if (!(project.mock && project.mock.external)) {
+        tools.logInfo('No external mock setup...skipping')
+
+      } else {
+        return gitUtils.cloneRepo(project.mock.repository, project.mock.folder);
+      }
     })
 
     .catch((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,318 @@
+'use strict';
+
+const path = require('path');
+const _ = require('lodash');
+
+const tools = require('../../tools');
+const configUtils = require('../../../csdr/config/config-utils');
+
+
+const getEnvTarget = (envTarget, build) => {
+  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,26 +90,30 @@ 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'),
           path.join(project.paths.angularPath, `${rootTargetFolder}/assets/oidc-client.min.js`)
         );
+        tools.logSuccess();
+
+        tools.logInfo(`Copying node_modules/jsrsasign/lib/jsrsasign-all-min.js to ${rootTargetFolder}/assets/jsrsasign-all-min.js`);
         tools.copy(
           path.join(process.cwd(), 'node_modules/jsrsasign/lib/jsrsasign-all-min.js'),
           path.join(project.paths.angularPath, `${rootTargetFolder}/assets/jsrsasign-all-min.js`)
         );
+        tools.logSuccess();
+
+        tools.logInfo(`Copying node_modules/@eui/base/assets/openid/openid-login.js to ${rootTargetFolder}/assets/openid-login.js`);
         tools.copy(
           path.join(process.cwd(), 'node_modules/@eui/base/assets/openid/openid-login.js'),
           path.join(project.paths.angularPath, `${rootTargetFolder}/assets/openid-login.js`)
         );
+        tools.logSuccess();
       }
 
       if (configEnvTarget) {
-        return this.injectAppConfig(project, configEnvTarget, build);
+        return this.injectAppConfig(project, configEnvTarget);
       }
     })
 
@@ -114,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`);
@@ -128,12 +138,15 @@ module.exports.injectAppConfig = (project, configEnvTarget, build) => {
       }
 
       let rootTargetFolder = 'src';
-      if (build) {
-        rootTargetFolder = 'dist';
-      }
+      let replacedFile;
 
-      tools.logInfo(`Replacing default ${rootTargetFolder}/assets/env-json-config.json file by ${envFilePath} content`);
-      tools.copy(envFilePath, path.join(project.paths.angularPath, `${rootTargetFolder}/assets/config/env-json-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();
     })