@eui/tools 6.12.29 → 6.12.30

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

@@ -1,776 +0,0 @@
-'use strict';
-
-const path = require('path');
-const _ = require('lodash');
-
-const tools = require('../../tools');
-const configUtils = require('../../../csdr/config/config-utils');
-const initUtils = require('../../../csdr/init/init-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();
-
-    if (!envTarget) {
-      throw 'ENV_TARGET_NOT_FOUND';
-    } else {
-      envTargetIn = envTarget;
-    }
-  }
-
-  let envTargetFinal = envTargetIn.toLowerCase();
-
-  if (build) {
-    // dirty fix as openid files do not respect envTarget names
-    if (envTargetFinal === 'tst') {
-      envTargetFinal = 'test';
-    }
-
-    // serve configuration based
-  } else {
-    if (envTargetIn.indexOf('local') > -1) {
-      envTargetFinal = envTargetIn.replace('-openid', '');
-    } else {
-      envTargetFinal = 'local-' + envTargetFinal;
-    }
-  }
-
-  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');
-
-  return Promise.resolve()
-    .then(() => {
-      if (!project.externalRoutesSources) {
-        tools.logError('project requires externalRoutesSources definition');
-        return;
-      }
-
-      let routesFilePath;
-      let srcRoutesFilePath;
-
-      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;
-      })[0];
-
-      // if local package is found
-      if (localPackage) {
-        tools.logInfo('local package found, copying from local');
-
-        tools.logInfo(`constructing route path with eUI version provided: ${euiVersion}`);
-
-        srcRoutesFilePath = path.join(
-          process.cwd(),
-          'packages',
-          localPackage.name,
-          'assets',
-          euiVersion,
-          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.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
-        );
-      }
-
-      routesFilePath = path.join(project.paths.rootPath, project.externalRoutesSources.routesFilePath);
-
-      // copy source file to project destination
-      tools.copy(srcRoutesFilePath, routesFilePath);
-
-      // checking is routes path declared
-      if (!tools.isFileExists(routesFilePath)) {
-        tools.logError(`Unable to find ${routesFilePath}`);
-        return;
-      }
-
-      return routesFilePath;
-    })
-
-    .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';
-
-  routeContent += `  path: '${route.path}',\n`;
-  if (Object.keys(route.data).length > 0) {
-    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 += `  ${route.loadChildren},\n`;
-  }
-  routeContent += '},\n\n';
-
-  return routeContent;
-};
-
-/**
- * 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...');
-
-      // source of all routes - routes defs base
-      const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
-
-      const routeDefsBaseFilename = 'route-defs-base.json';
-      const routeDefsBaseJSON = require(path.join(projectAssetsPath, routeDefsBaseFilename));
-
-      // getting generated from input params
-      const euiVersionNumber = euiVersion.split('.')[0];
-      const envTargetFinal = getEnvTarget(envTarget, build);
-
-      tools.logInfo(`Processing for envTarget : ${envTargetFinal}`);
-
-      // 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 :
-      //    playground : "routesFilenameTemplate": "route-defs-base-v@eui.version@-playground.json"
-      //    host : "routesFilenameTemplate": "route-defs.@env.target@.json"
-
-      let routeDefsInputFilename;
-
-      if (!project.externalRoutesSources.routesFilenameTemplate) {
-        throw 'ROUTES_CONFIG_V2_TEMPLATE_NOT_FOUND';
-      }
-
-
-      routeDefsInputFilename = project.externalRoutesSources.routesFilenameTemplate.replace('@eui.version@', euiVersionNumber);
-      routeDefsInputFilename = routeDefsInputFilename.replace('@env.target@', envTargetFinal);
-
-      tools.logInfo(`Starting replacement of routes based on generated template : ${routeDefsInputFilename}`);
-
-      // Getting input routeDefs entry
-
-      const routeDefsInputPath = path.join(projectAssetsPath, routeDefsInputFilename);
-
-      if (!tools.isFileExists(routeDefsInputPath)) {
-        tools.logError(`${routeDefsInputPath} File NOT FOUND`);
-        throw 'ROUTE_DEFS_INPUT_FILE_NOT_FOUND';
-      }
-
-      const routeDefsInputJSON = require(path.join(routeDefsInputPath));
-
-      // Merging content with "local" route file defs if existing
-
-      let mergedRoutes = [];
-
-      if (envTargetFinal.indexOf('local') > -1) {
-        const localRouteDefsInputFilename = `route-defs.${envTargetFinal}.json`;
-        const localRouteDefsInputPath = path.join(projectAssetsPath, localRouteDefsInputFilename);
-
-        if (tools.isFileExists(localRouteDefsInputPath)) {
-          tools.logInfo(`Merging local configuration found : ${localRouteDefsInputFilename}`);
-          const localRouteDefsInputJSON = require(path.join(localRouteDefsInputPath));
-
-          routeDefsInputJSON.forEach((route) => {
-            const matchedRoute = localRouteDefsInputJSON.filter(newRoute => newRoute.path === route.path)[0];
-            if (matchedRoute) {
-              tools.logInfo(`-- replacing ${route.path} route entry with overriden local config`);
-              tools.logInfo(`-----> ${JSON.stringify(matchedRoute)}`);
-              mergedRoutes.push(matchedRoute);
-            } else {
-              mergedRoutes.push(route);
-            }
-          });
-        }
-      } else {
-        mergedRoutes = routeDefsInputJSON;
-      }
-
-      const appRoutes = [],
-        appFeatureLibs = [],
-        finalRemotesDefs = [];
-
-      // processing each routes found in the routeDefs entry
-
-      mergedRoutes.forEach((route) => {
-        tools.logInfo(`Processing route : `);
-        console.log(route);
-
-        const defRoute = routeDefsBaseJSON.filter((r) => r.path === route.path)[0];
-        if (!defRoute) {
-          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];
-            const lazyFeatureLibName = `${scopeName}-${pkgName}-${defRoute.lazyLoadDef.moduleName}.lib.module`;
-
-            if (euiVersion === '10.x') {
-              loadChildrenGenerated = `loadChildren: "./features/${lazyFeatureLibName}#Module"`;
-            } else {
-              loadChildrenGenerated = `loadChildren: () => import("./features/${lazyFeatureLibName}").then(m => m.Module)`;
-            }
-
-            appFeatureLibs.push({
-              filename: `${lazyFeatureLibName}.ts`,
-              npmPkg: defRoute.lazyLoadDef.npmPkg,
-              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"';
-            } else {
-              loadChildrenGenerated = 'loadChildren: () => import("./features/element-loader.module").then(m => m.ElementLoaderModule)';
-            }
-          }
-
-          // we define the route item definition, that will be injected in the project app.routes source
-          const newAppRoute = {
-            path: defRoute.path,
-            loadChildren: loadChildrenGenerated,
-            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) {
-            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
-
-      tools.logInfo('Processing creation of features lib modules entries');
-
-      appFeatureLibs.forEach((f) => {
-        const featureLibPath = path.join(process.cwd(), project.folder, 'src', 'app', 'features', f.filename);
-
-        const featureLibDef = `
-          import { NgModule } from '@angular/core';
-          import { ${f.moduleName} as LibModule } from '${f.npmPkg}';
-
-          @NgModule({
-              imports: [LibModule],
-              exports: [LibModule],
-          })
-          export class Module {
-          }
-        `;
-
-        tools.logInfo(`Creating lazy feature lib module : ${f.filename}`);
-
-        tools.writeFileContent(featureLibPath, featureLibDef);
-      });
-
-      // 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));
-
-      tools.logInfo('Processing links generation');
-
-      const getRouteMenuDef = (link) => {
-        let routeDef = null;
-
-        if (link.url) {
-          routeDefsBaseJSON.forEach((r) => {
-            if (r.menuLinkDefs && r.menuLinkDefs.length > 0) {
-              r.menuLinkDefs.forEach((md) => {
-                if (md.url === link.url) {
-                  routeDef = md;
-                  if (link.id) {
-                    routeDef.id = link.id;
-                  }
-                  if (link.optional) {
-                    routeDef.optional = link.optional;
-                  }
-                  if (link.workspace) {
-                    routeDef.workspace = link.workspace;
-                  }
-                  return;
-                }
-              });
-            }
-          });
-        }
-
-        return routeDef;
-      };
-
-      const getRouteDefFromMenuLink = (link) => {
-        let routeDef = null;
-
-        if (link.url) {
-          routeDefsBaseJSON.forEach((r) => {
-            if (r.menuLinkDefs && r.menuLinkDefs.length > 0) {
-              r.menuLinkDefs.forEach((md) => {
-                if (md.url === link.url) {
-                  routeDef = r;
-                  return;
-                }
-              });
-            }
-          });
-        }
-
-        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
-        if (envTargetFinal.indexOf('local') > -1) {
-          return true;
-        }
-
-        // checking if current envTarget generated is allowed
-        if (link.allowedEnvs) {
-          if (link.allowedEnvs.includes(envTargetFinal)) {
-            return true;
-          } else {
-            return false;
-          }
-        } else {
-          return true;
-        }
-      };
-
-      // processing each link and matching route from routes base data definitions
-
-      const linksGenerated = [];
-
-      routeDefsBaseLinksJSON.forEach((link) => {
-        let newLink;
-
-        if (link.parentId) {
-          if (isLinkAllowed(link)) {
-            newLink = { ...link };
-            newLink.children = [];
-
-            link.children.forEach((subLink) => {
-              if (isLinkAllowed(subLink)) {
-                const defRoute = getRouteMenuDef(subLink);
-
-                if (defRoute) {
-                  newLink.children.push(defRoute);
-                }
-              }
-            });
-          }
-        } else {
-          if (isLinkAllowed(link)) {
-            const defRoute = getRouteMenuDef(link);
-
-            if (defRoute) {
-              newLink = defRoute;
-            } else {
-              newLink = link;
-            }
-
-            if (link.alwaysDisplayed) {
-              newLink.alwaysDisplayed = true;
-            }
-          }
-        }
-
-        if (newLink) {
-          linksGenerated.push(newLink);
-        }
-
-        if (debug) {
-          console.log('Links generated');
-          console.log(JSON.stringify(linksGenerated));
-        }
-      });
-
-      tools.logInfo(`Links generated : ${linksGenerated.length} found`);
-
-      // checking if in playground route mode (local dev), in this case we mark the non-existing routes
-      // as disabled locally
-      let finalLinksGenerated = [];
-      if (project.externalRoutesSources.routesFilenameTemplate.indexOf('playground') > 0) {
-        tools.logInfo('Disabling non-active routes for playground');
-
-        linksGenerated.forEach((link) => {
-          let newLink = link;
-
-          if (link.parentId) {
-            let newLinkChildren = [];
-
-            link.children.forEach((subLink) => {
-              const defRoute = getRouteDefFromMenuLink(subLink);
-
-              if (defRoute) {
-                const routePathInInputRoutes = mergedRoutes.filter(r => r.path === defRoute.path)[0];
-
-                if (!routePathInInputRoutes) {
-                  subLink.disabled = true;
-
-                } else {
-                  tools.logInfo(`[${subLink.url}] --> route found in input routes - enabled`);
-                }
-              }
-              newLinkChildren.push(subLink);
-            });
-            newLink.children = newLinkChildren;
-
-            const enabledChildren = newLink.children.filter(c => !c.disabled);
-            if (enabledChildren.length === 0) {
-              newLink.disabled = true;
-            }
-
-          } else {
-            const defRoute = getRouteDefFromMenuLink(link);
-
-            if (defRoute) {
-              const routePathInInputRoutes = mergedRoutes.filter(r => r.path === defRoute.path)[0];
-
-              if (!routePathInInputRoutes) {
-                newLink.disabled = true;
-              } else {
-                tools.logInfo(`[${link.url}] --> route found in input routes - enabled`);
-              }
-            }
-          }
-
-          finalLinksGenerated.push(newLink);
-        });
-
-      } else {
-        finalLinksGenerated = linksGenerated;
-      }
-
-      tools.writeJsonFileSync(path.join(projectAssetsPath, 'route-defs-links.json'), finalLinksGenerated);
-
-      // getting routes content for replacement
-
-      tools.logInfo('Processing routes replacement');
-
-      let placeHolderContent = '';
-
-      appRoutes.forEach((route) => {
-        placeHolderContent += replaceRoute(route);
-      });
-
-      const placeHolderToken = '// routes-placeholder';
-      routesFileContent = tools.replaceAll(routesFileContent, placeHolderToken, placeHolderContent);
-
-      if (debug) {
-        tools.logInfo('Routes file content replaced : ');
-        console.log(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;
-  })[0];
-
-  var pkgAssetsPath;
-  const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
-
-  // if local package is found
-  if (localPackage) {
-    pkgAssetsPath = path.join(process.cwd(), 'packages', localPackage.name, 'assets');
-
-    // 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);
-    pkgAssetsPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, 'assets');
-  }
-
-  if (!tools.isDirExists(pkgAssetsPath)) {
-    tools.logWarning(`Linked config pkg : ${npmPkg} cannot be found in node_modules`);
-    return;
-  }
-
-  const routesConfigPath = path.join(pkgAssetsPath, project.externalRoutesSources.routesConfigAssetsPath);
-
-  tools.logInfo(`${routesConfigPath} - injecting in ${projectAssetsPath}`);
-  tools.copydir(routesConfigPath, projectAssetsPath);
-};
-
-
-module.exports.extractRemotesMetadata = (project) => {
-  tools.logTitle('Extracting remotes-metadata.json for known participant remotes');
-
-  const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
-  const openidConfigFile = path.join(projectAssetsPath, 'openid-login-config.json');
-  const finalRemotesDefsFile = path.join(projectAssetsPath, 'remotes-metadata.json');
-
-  if (!tools.isFileExists(finalRemotesDefsFile)) {
-    tools.logInfo('...remotes-metadata.json not found / not previously generated ... skipping');
-    return;
-  }
-
-  return Promise.resolve()
-    .then(() => {
-      return initUtils.remotes.cloneRemotesConfig();
-    })
-
-    .then(() => {
-      let remoteMetadataJSON = tools.getJsonFileContent(finalRemotesDefsFile);
-      const openidConfigJSON = tools.getJsonFileContent(openidConfigFile);
-
-      remoteMetadataJSON.forEach((r) => {
-        tools.logInfo(`Fetching remote info for : ${r}`);
-
-        let remote;
-        if (configUtils.remotes.isVirtualRemote(r)) {
-          remote = configUtils.remotes.getRemote(r);
-        } else {
-          remote = configUtils.packages.getPackage(r, true, true);
-        }
-
-        if (remote && remote.build && remote.build.hasParticipants) {
-          let participantsList;
-          if (remote.euiVersion === '15.x') {
-            participantsList = openidConfigJSON.modules[remote.build.configModuleName].participants_v15
-          } else {
-            participantsList = openidConfigJSON.modules[remote.build.configModuleName].participants
-          }
-          if (participantsList) {
-            let participantRemotes = [];
-            Object.keys(participantsList).forEach((p) => {
-              participantRemotes.push(participantsList[p].moduleId);
-            });
-            tools.logInfo('Found participant remotes : ');
-            console.log(participantRemotes);
-
-            remoteMetadataJSON = [...remoteMetadataJSON, ...participantRemotes];
-          }
-        }
-      })
-
-      remoteMetadataJSON = tools.removeArrayDuplicates(remoteMetadataJSON);
-
-      tools.logInfo('Final remotes metadata list found :');
-      console.log(remoteMetadataJSON);
-
-      return tools.writeJsonFileSync(finalRemotesDefsFile, remoteMetadataJSON);
-  })
-
-  .catch((e) => {
-    throw e;
-  });
-}