@eui/tools 6.13.16 → 6.14.1

package/scripts/csdr/install/common.js

@@ -12,7 +12,6 @@ const metadataUtils = require('../metadata/metadata-utils');
 // FETCH ARGS
 const { dryRun, skipInstall, registry, skipLocalPackagesDeps } = tools.getArgs();
 
-
 const getInstallRegistry = () => {
   const NPM_REGISTRY_INSTALL = configUtils.global.getConfigOptions().NPM_REGISTRY_INSTALL;
 
@@ -25,72 +24,68 @@ const getInstallRegistry = () => {
   }
 
   return installRegistry;
-}
-
+};
 
 module.exports.installDeps = (deps) => {
-
+  return (
+    Promise.resolve()
+      // Install dependencies
+      .then(() => {
+        tools.logTitle('Package dependencies to install : ');
+
+        const rootFolder = process.cwd();
+        const pkgJsonFile = path.resolve(rootFolder, 'package.json');
+        const pkgJson = require(pkgJsonFile);
+
+        pkgJson.dependencies = deps;
+
+        // Updating file and installing
+        if (Object.keys(pkgJson.dependencies).length !== 0) {
+          tools.writeJsonFileSync(pkgJsonFile, pkgJson);
+          tools.logInfo('installing dependencies');
+          console.log(pkgJson.dependencies);
+
+          return executeInstall(rootFolder);
+        }
+      })
+
+      .catch((e) => {
+        throw e;
+      })
+  );
+};
+
+const executeInstall = (module.exports.executeInstall = (cwdPath) => {
   return Promise.resolve()
-  // Install dependencies
-  .then(() => {
-    tools.logTitle('Package dependencies to install : ');
-
-    const rootFolder = process.cwd();
-    const pkgJsonFile = path.resolve(rootFolder, 'package.json');
-    const pkgJson = require(pkgJsonFile);
-
-      pkgJson.dependencies = deps;
-
-      // Updating file and installing
-      if (Object.keys(pkgJson.dependencies).length !== 0) {
-        tools.writeJsonFileSync(pkgJsonFile, pkgJson);
-        tools.logInfo('installing dependencies');
-        console.log(pkgJson.dependencies);
+    .then(() => {
+      const installRegistry = getInstallRegistry();
 
-        return executeInstall(rootFolder);
+      tools.logInfo(`Install from : ${installRegistry}`);
+      if (!dryRun && !skipInstall) {
+        return execa.shellSync(`yarn --registry ${installRegistry}`, { cwd: cwdPath, stdio: 'inherit' });
       }
     })
 
     .catch((e) => {
       throw e;
-    })
-}
-
+    });
+});
 
-const executeInstall = module.exports.executeInstall = (cwdPath) => {
+module.exports.executeInstallPackage = (cwdPath, npmPkg) => {
   return Promise.resolve()
     .then(() => {
       const installRegistry = getInstallRegistry();
 
-      tools.logInfo(`Install from : ${installRegistry}`);
+      tools.logInfo(`Install ${npmPkg} from : ${installRegistry}`);
       if (!dryRun && !skipInstall) {
-        return execa.shellSync(`yarn --registry ${installRegistry}`, { cwd: cwdPath, stdio: 'inherit' });
+        return execa.shellSync(`yarn add ${npmPkg} --no-lockfile --registry ${installRegistry}`, { cwd: cwdPath, stdio: 'inherit' });
       }
     })
 
     .catch((e) => {
       throw e;
-    })
-}
-
-
-module.exports.executeInstallPackage = (cwdPath, npmPkg) => {
-  return Promise.resolve()
-  .then(() => {
-    const installRegistry = getInstallRegistry();
-
-    tools.logInfo(`Install ${npmPkg} from : ${installRegistry}`);
-    if (!dryRun && !skipInstall) {
-      return execa.shellSync(`yarn add ${npmPkg} --no-lockfile --registry ${installRegistry}`, { cwd: cwdPath, stdio: 'inherit' });
-    }
-  })
-
-  .catch((e) => {
-    throw e;
-  })
-}
-
-
+    });
+};
 
 module.exports.getResolvedCarretDeps = (deps, isMaster, isDevEnvTarget) => {
   tools.logTitle('Resolving carret versions for prev or next version packages');
@@ -98,27 +93,30 @@ module.exports.getResolvedCarretDeps = (deps, isMaster, isDevEnvTarget) => {
   tools.logInfo('processing dependencies : ');
   console.log(deps);
 
-  return Promise.resolve()
-    .then(() => {
-
-      const dependencies = Object.keys(deps)
-        .reduce((acc, k) => {
+  return (
+    Promise.resolve()
+      .then(() => {
+        const dependencies = Object.keys(deps).reduce((acc, k) => {
           if (deps[k] && deps[k].substr(0, 1) === '^') {
             const npmPkg = k;
-            const version = deps[k]
+            const version = deps[k];
 
             tools.logInfo(`Processing ${npmPkg}:${version}`);
 
             // getting package from npmPkg
-            const pkg =  configUtils.packages.getPackageByNpmPkg(npmPkg, true);
+            const pkg = configUtils.packages.getPackageByNpmPkg(npmPkg, true);
 
             // getting last major version from metadata history for pkg found
-            const lastMajorVersion = metadataUtils.package.getLastMajorVersion(pkg, version.substr(1).split('.')[0], isMaster, isDevEnvTarget);
+            const lastMajorVersion = metadataUtils.package.getLastMajorVersion(
+              pkg,
+              version.substr(1).split('.')[0],
+              isMaster,
+              isDevEnvTarget
+            );
 
             if (lastMajorVersion) {
               tools.logInfo(`--version found : ${lastMajorVersion}`);
               acc[k] = lastMajorVersion;
-
             } else {
               tools.logWarning(`WARNING : Can't resolve carret version from history for pkg: ${npmPkg} for version ${version}`);
             }
@@ -126,14 +124,14 @@ module.exports.getResolvedCarretDeps = (deps, isMaster, isDevEnvTarget) => {
           return acc;
         }, {});
 
-      return { ...deps, ...dependencies };
-    })
-
-    // don't rethrow in case of error, just log the exception
-    .catch((e) => {
-      tools.logError('Unable to resolve deps');
-      console.log(e);
-      return deps;
-    })
-}
-
+        return { ...deps, ...dependencies };
+      })
+
+      // don't rethrow in case of error, just log the exception
+      .catch((e) => {
+        tools.logError('Unable to resolve deps');
+        console.log(e);
+        return deps;
+      })
+  );
+};

package/scripts/csdr/install/projects.js

@@ -15,9 +15,7 @@ const innerCompositeCore = require('./composite-core');
 // FETCH ARGS
 const { remotesImport } = tools.getArgs();
 
-
-
-const getDeps = module.exports.getDeps = (prj, envTarget, compositeType) => {
+const getDeps = (module.exports.getDeps = (prj, envTarget, compositeType) => {
   return Promise.resolve()
     .then(() => {
       return metadataUtils.appEnvs.getMetadata(prj);
@@ -34,11 +32,8 @@ const getDeps = module.exports.getDeps = (prj, envTarget, compositeType) => {
 
     .catch((e) => {
       throw e;
-    })
-}
-
-
-
+    });
+});
 
 const getLocalProjectDeps = (prj, snapshotsMetadata) => {
   tools.logInfo(`Getting deps for ${prj.name}`);
@@ -55,12 +50,11 @@ const getLocalProjectDeps = (prj, snapshotsMetadata) => {
   if (depsJson.dependencies) {
     prjCompDeps = depsJson.dependencies || {};
   } else {
-    prjCompDeps = depsJson || {}
+    prjCompDeps = depsJson || {};
   }
 
   return { ...prjDeps, ...prjCompDeps };
-}
-
+};
 
 module.exports.getLocalProjectsDeps = () => {
   tools.logTitle('Getting project dependencies');
@@ -68,18 +62,17 @@ module.exports.getLocalProjectsDeps = () => {
   const projects = configUtils.projects.getProjects();
   let deps = {};
 
-  projects.forEach(p => {
+  projects.forEach((p) => {
     if (p) {
       const prjDeps = getLocalProjectDeps(p);
       deps = { ...deps, ...prjDeps };
     }
-  })
+  });
 
   return deps;
-}
-
+};
 
-const getLocalProjectFixedDeps = module.exports.getLocalProjectFixedDeps = (prj) => {
+const getLocalProjectFixedDeps = (module.exports.getLocalProjectFixedDeps = (prj) => {
   tools.logTitle('Getting project fixed dependencies - not part of the composite');
 
   return Promise.resolve()
@@ -92,9 +85,9 @@ const getLocalProjectFixedDeps = module.exports.getLocalProjectFixedDeps = (prj)
 
         prj.fixedDependencies.forEach((dep) => {
           const pkg = configUtils.packages.getPackageByNpmPkg(dep, true);
-          const newDep = { [dep]: metadataUtils.package.getPackageVersionLast(pkg)};
-          deps = { ...deps, ...newDep }
-        })
+          const newDep = { [dep]: metadataUtils.package.getPackageVersionLast(pkg) };
+          deps = { ...deps, ...newDep };
+        });
       }
 
       tools.logInfo('Project fixed dependencies remapped : ');
@@ -105,28 +98,22 @@ const getLocalProjectFixedDeps = module.exports.getLocalProjectFixedDeps = (prj)
 
     .catch((e) => {
       throw e;
-    })
-}
-
+    });
+});
 
-module.exports.getLocalProjectsFixedDeps = async _ => {
+module.exports.getLocalProjectsFixedDeps = async (_) => {
   const projects = configUtils.projects.getProjects();
   let deps = {};
 
-  const promises = projects.map(async prj => {
-    const prjDeps = await getLocalProjectFixedDeps(prj)
-    deps = { ...deps, ...prjDeps};
+  const promises = projects.map(async (prj) => {
+    const prjDeps = await getLocalProjectFixedDeps(prj);
+    deps = { ...deps, ...prjDeps };
     return deps;
-  })
+  });
 
   await Promise.all(promises);
   return deps;
-}
-
-
-
-
-
+};
 
 module.exports.installDeps = (prj, envTarget, compositeType) => {
   let finalDeps, compositeDeps;
@@ -171,8 +158,8 @@ module.exports.installDeps = (prj, envTarget, compositeType) => {
 
     .catch((e) => {
       throw e;
-    })
-}
+    });
+};
 
 module.exports.installDepsStandalone = (prj) => {
   return Promise.resolve()
@@ -182,15 +169,11 @@ module.exports.installDepsStandalone = (prj) => {
 
     .catch((e) => {
       throw e;
-    })
-}
-
-
-
-const getLocalProjectRemoteDeps = module.exports.getLocalProjectRemoteDeps = (prj) => {
+    });
+};
 
+const getLocalProjectRemoteDeps = (module.exports.getLocalProjectRemoteDeps = (prj) => {
   if (prj.initRemoteDependencies && remotesImport) {
-
     tools.logTitle(`Detecting remotes deps for project : ${prj.name}`);
 
     const euiVersion = configUtils.global.getLocalEuiVersion();
@@ -198,37 +181,35 @@ const getLocalProjectRemoteDeps = module.exports.getLocalProjectRemoteDeps = (pr
 
     let remoteDeps = {};
     remotes
-      .map(r => configUtils.remotes.getRemote(r.name))
+      .map((r) => configUtils.remotes.getRemote(r.name))
       .map((r) => {
-        return { npmgPkg: r.npmPkg, version: metadataUtils.package.getPackageVersionLast(r) }
+        return { npmgPkg: r.npmPkg, version: metadataUtils.package.getPackageVersionLast(r) };
       })
       .forEach((r) => {
         if (!r.version) {
-          tools.logInfo(`${r.npmgPkg} => no version found, probably the remote hasn't been released yet...skipping`)
+          tools.logInfo(`${r.npmgPkg} => no version found, probably the remote hasn't been released yet...skipping`);
         } else {
           remoteDeps[r.npmgPkg] = r.version;
         }
-      })
+      });
 
-      return remoteDeps;
+    return remoteDeps;
   }
-}
+});
 
-module.exports.getLocalProjectsRemoteDeps = async _ => {
+module.exports.getLocalProjectsRemoteDeps = async (_) => {
   const projects = configUtils.projects.getProjects();
   let deps = {};
 
-  const promises = projects.map(async prj => {
-    const prjDeps = await getLocalProjectRemoteDeps(prj)
-    deps = { ...deps, ...prjDeps};
+  const promises = projects.map(async (prj) => {
+    const prjDeps = await getLocalProjectRemoteDeps(prj);
+    deps = { ...deps, ...prjDeps };
     return deps;
-  })
+  });
 
   await Promise.all(promises);
   return deps;
-}
-
-
+};
 
 module.exports.importLocalProjectRemotes = (prj, remoteDeps) => {
   if (prj.initRemoteDependencies) {
@@ -238,7 +219,6 @@ module.exports.importLocalProjectRemotes = (prj, remoteDeps) => {
 
     if (remoteDeps.length === 0) {
       tools.logWarning('Remotes dependencies not found for project...skipping');
-
     } else {
       tools.logInfo(`Initializing ${remoteDeps.length} remotes`);
 
@@ -248,7 +228,6 @@ module.exports.importLocalProjectRemotes = (prj, remoteDeps) => {
         // check if package has been installed locally
         if (configUtils.remotes.isLocalRemote(remoteNpmPkg)) {
           tools.logInfo('remote is installed locally...skipping import');
-
         } else {
           const remote = configUtils.remotes.getRemoteByNpmPkg(remoteNpmPkg, true);
           const projectElementsPath = path.join(process.cwd(), prj.folder, 'src', 'assets', 'elements', remote.name, 'bundles');
@@ -263,8 +242,7 @@ module.exports.importLocalProjectRemotes = (prj, remoteDeps) => {
       });
     }
   }
-}
-
+};
 
 module.exports.importLocalProjectsRemotes = (deps) => {
   const projects = configUtils.projects.getProjects();
@@ -272,11 +250,10 @@ module.exports.importLocalProjectsRemotes = (deps) => {
   tools.logTitle('Importing local projects remotes');
 
   if (remotesImport) {
-    projects.forEach(p => {
+    projects.forEach((p) => {
       if (p) {
         this.importLocalProjectRemotes(p, deps);
       }
-    })
+    });
   }
-}
-
+};

package/scripts/csdr/metadata/app.js

@@ -16,7 +16,6 @@ const innerPackage = require('./package');
 // FETCH ARGS
 const { dryRun } = tools.getArgs();
 
-
 const getMetadata = (project) => {
   const DEVOPS_METADATA_PATH = configUtils.global.getConfigOptions().DEVOPS_METADATA_PATH;
 
@@ -30,12 +29,11 @@ const getMetadata = (project) => {
     })
     .catch((e) => {
       throw e;
-    })
-}
-
+    });
+};
 
 const storeMetadata = (project, newVersion, metadata, envTarget) => {
-  const appReleaseDate = moment(new Date()).format("DD/MM/YYYY HH:mm");
+  const appReleaseDate = moment(new Date()).format('DD/MM/YYYY HH:mm');
   const appInfos = `${newVersion} - ${appReleaseDate}`;
   const DEVOPS_METADATA_PATH = configUtils.global.getConfigOptions().DEVOPS_METADATA_PATH;
 
@@ -61,7 +59,7 @@ const storeMetadata = (project, newVersion, metadata, envTarget) => {
         releaseDate: appReleaseDate,
         infos: appInfos,
         packages: metadata,
-        envTarget: envTarget
+        envTarget: envTarget,
       });
 
       generatedMetadata.versions = versions;
@@ -77,63 +75,59 @@ const storeMetadata = (project, newVersion, metadata, envTarget) => {
 
     .catch((e) => {
       throw e;
-    })
-}
-
-
+    });
+};
 
 const storeMetadataAssets = (project, newVersion, packagesDeps, historyMetadata, envTarget) => {
-  const appReleaseDate = moment(new Date()).format("DD/MM/YYYY HH:mm");
+  const appReleaseDate = moment(new Date()).format('DD/MM/YYYY HH:mm');
   const appInfos = `${newVersion} - ${appReleaseDate}`;
 
   tools.logTitle('Storing app assets metadata');
 
-  return Promise.resolve()
-    // storing metadata file
-    .then(() => {
-      tools.logInfo('Storing app metadata into project assets');
-
-      const appMetadata = {
-        appVersion: newVersion,
-        appReleaseDate: appReleaseDate,
-        appInfos: appInfos,
-        metadata: packagesDeps,
-      };
+  return (
+    Promise.resolve()
+      // storing metadata file
+      .then(() => {
+        tools.logInfo('Storing app metadata into project assets');
 
-      const metadataFile = path.join(project.folder, 'src', 'assets', 'app-metadata.json');
+        const appMetadata = {
+          appVersion: newVersion,
+          appReleaseDate: appReleaseDate,
+          appInfos: appInfos,
+          metadata: packagesDeps || {},
+        };
 
-      tools.logInfo(`Creating ${metadataFile}`);
-      console.log(appMetadata);
-
-      if (!dryRun) {
-        return tools.writeJsonFileSync(metadataFile, appMetadata);
-      }
-    })
+        const metadataFile = path.join(project.folder, 'src', 'assets', 'app-metadata.json');
 
+        tools.logInfo(`Creating ${metadataFile}`);
+        console.log(appMetadata);
 
-    .then(() => {
-      tools.logInfo('Storing app env delta metadata into project assets');
+        if (!dryRun) {
+          return tools.writeJsonFileSync(metadataFile, appMetadata);
+        }
+      })
 
-      if (!historyMetadata) {
-        tools.logInfo('no history metadata found...skipping');
+      .then(() => {
+        tools.logInfo('Storing app env delta metadata into project assets');
 
-      } else {
-        const metadataFile = path.join(project.folder, 'src', 'assets', 'app-metadata-history.json');
+        if (!historyMetadata) {
+          tools.logInfo('no history metadata found...skipping');
+        } else {
+          const metadataFile = path.join(project.folder, 'src', 'assets', 'app-metadata-history.json');
 
-        tools.logInfo(`Creating ${metadataFile}`);
+          tools.logInfo(`Creating ${metadataFile}`);
 
-        if (!dryRun && envTarget && envTarget !== 'DEV') {
-          return tools.writeJsonFileSync(metadataFile, historyMetadata);
+          if (!dryRun && envTarget && envTarget !== 'DEV') {
+            return tools.writeJsonFileSync(metadataFile, historyMetadata);
+          }
         }
-      }
-    })
-
-
-    .catch((e) => {
-      throw e;
-    })
-}
+      })
 
+      .catch((e) => {
+        throw e;
+      })
+  );
+};
 
 const storeMetadataAssetsStandAlone = () => {
   tools.logTitle('App metadata generation');
@@ -142,78 +136,76 @@ const storeMetadataAssetsStandAlone = () => {
   const prj = configUtils.projects.getProject();
   let currentVersion, packageDeps, packageDepsMetadata;
 
-  return Promise.resolve()
-    // getting current app version
-    .then(() => {
-      return versionUtils.app.getCurrentVersion(prj);
-    })
-    .then((version) => {
-      currentVersion = version;
-    })
-
-    // getting packages composite deps version
-    .then(() => {
-      return installUtils.projects.getDeps(prj);
-    })
-    .then((deps) => {
-      packageDeps = deps;
-
-      packageDepsMetadata = Object.keys(deps).map((d) => {
-        const pkg = configUtils.packages.getPackageByNpmPkg(d, true);
-        tools.logInfo(`getting pkg versions metadata for : ${pkg.name} / version: ${deps[d]}`);
-        const pkgVersionMetadata = innerPackage.getVersionMetadata(pkg, deps[d]);
-
-        if (!pkgVersionMetadata) {
-          tools.logWarning(`===> version of pkg not found in metadata, probably caused by a failure of the package build`);
-
-        } else {
-          return {
-            npmPkg: d,
-            repository: pkgVersionMetadata.name,
-            version: pkgVersionMetadata.version,
-            releaseDate: pkgVersionMetadata.date,
-            buildDuration: pkgVersionMetadata.duration,
+  return (
+    Promise.resolve()
+      // getting current app version
+      .then(() => {
+        return versionUtils.app.getCurrentVersion(prj);
+      })
+      .then((version) => {
+        currentVersion = version;
+      })
+
+      // getting packages composite deps version
+      .then(() => {
+        return installUtils.projects.getDeps(prj);
+      })
+      .then((deps) => {
+        packageDeps = deps;
+
+        packageDepsMetadata = Object.keys(deps).map((d) => {
+          const pkg = configUtils.packages.getPackageByNpmPkg(d, true);
+          tools.logInfo(`getting pkg versions metadata for : ${pkg.name} / version: ${deps[d]}`);
+          const pkgVersionMetadata = innerPackage.getVersionMetadata(pkg, deps[d]);
+
+          if (!pkgVersionMetadata) {
+            tools.logWarning(`===> version of pkg not found in metadata, probably caused by a failure of the package build`);
+          } else {
+            return {
+              npmPkg: d,
+              repository: pkgVersionMetadata.name,
+              version: pkgVersionMetadata.version,
+              releaseDate: pkgVersionMetadata.date,
+              buildDuration: pkgVersionMetadata.duration,
+            };
           }
-        }
-      });
-    })
-
-    // storing metadata
-    .then(() => {
-      tools.logInfo('Storing app metadata into project assets');
-
-      const appReleaseDate = moment(new Date()).format("DD/MM/YYYY HH:mm");
-      const appInfos = `${currentVersion} - ${appReleaseDate}`;
+        });
+      })
 
-      const appMetadata = {
-        appVersion: currentVersion,
-        appReleaseDate: appReleaseDate,
-        appInfos: appInfos,
-        metadata: packageDeps,
-        metadataDetails: packageDepsMetadata
-      };
+      // storing metadata
+      .then(() => {
+        tools.logInfo('Storing app metadata into project assets');
 
-      const metadataFile = path.join(prj.folder, 'src', 'assets', 'app-metadata.json');
+        const appReleaseDate = moment(new Date()).format('DD/MM/YYYY HH:mm');
+        const appInfos = `${currentVersion} - ${appReleaseDate}`;
 
-      tools.logInfo(`Creating ${metadataFile}`);
-      console.log(JSON.stringify(appMetadata, null, 2));
+        const appMetadata = {
+          appVersion: currentVersion,
+          appReleaseDate: appReleaseDate,
+          appInfos: appInfos,
+          metadata: packageDeps,
+          metadataDetails: packageDepsMetadata,
+        };
 
-      if (!dryRun) {
-        return tools.writeJsonFileSync(metadataFile, appMetadata);
-      }
-    })
+        const metadataFile = path.join(prj.folder, 'src', 'assets', 'app-metadata.json');
 
-    .catch((e) => {
-      throw e;
-    })
-}
+        tools.logInfo(`Creating ${metadataFile}`);
+        console.log(JSON.stringify(appMetadata, null, 2));
 
+        if (!dryRun) {
+          return tools.writeJsonFileSync(metadataFile, appMetadata);
+        }
+      })
 
+      .catch((e) => {
+        throw e;
+      })
+  );
+};
 
 module.exports = {
   getMetadata,
   storeMetadata,
   storeMetadataAssets,
   storeMetadataAssetsStandAlone,
-}
-
+};