@eui/tools 5.0.0-rc.9 → 5.1.0

package/scripts/csdr/install/local-dev.js

@@ -11,12 +11,14 @@ const metadataUtils = require('../metadata/metadata-utils');
 
 // INNER MODULES
 const innerCommon = require('./common');
-const innerRemote = require('./remote');
+const innerRemotes = require('./remotes');
 
 // FETCH ARGS
 const { dryRun, skipInstall } = tools.getArgs();
 
 
+
+
 module.exports.install = (pkg) => {
   let packagesDeps, packagesCompositeDeps, projectsDeps, projectsFixedDeps, finalDeps;
 
@@ -24,7 +26,7 @@ module.exports.install = (pkg) => {
 
     // cloning devops metadata repo
     .then(() => {
-      return metadataUtils.common.cloneMetadataRepo();
+      return metadataUtils.common.cloneMetadataRepo(true);
     })
 
 
@@ -83,7 +85,7 @@ module.exports.install = (pkg) => {
       tools.logInfo('Packages composite deps found : ');
       console.log(packagesCompositeDeps);
 
-      return innerCommon.getRemappedDeps(depsMetadata, configDeps);
+      return innerCommon.getRemappedDeps(depsMetadata, configDeps, false);
     })
 
 
@@ -98,7 +100,7 @@ module.exports.install = (pkg) => {
 
     // checking remotes
     .then(() => {
-      return innerRemote.installDeps(pkg);
+      return innerRemotes.installDeps(pkg);
     })
 
     .then(() => {

package/scripts/csdr/install/packages.js

@@ -0,0 +1,90 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+const glob = require('glob');
+
+// LOCAL
+const tools = require('../../utils/tools');
+const configUtils = require('../config/config-utils');
+const metadataUtils = require('../metadata/metadata-utils');
+
+// INNER MODULES
+const innerCommon = require('./common');
+const innerProjects = require('./projects');
+
+
+module.exports.installDeps = (prj, pkg) => {
+  let compositeDeps, localPkgDeps, localPkgCompositeDeps;
+
+  return Promise.resolve()
+    .then(() => {
+      // when package is built against an app (depends on this app deps defined)
+      // the composite deps of that app is returned (default to DEV target)
+      if (prj) {
+        return innerProjects.getDeps(prj);
+
+      // when package is stand-alone, then we take only the deps from within the package.json
+      } else {
+        return {};
+      }
+    })
+
+    .then((deps) => {
+      // storing
+      compositeDeps = deps;
+
+      tools.logInfo(`Found composite deps : `);
+      console.log(JSON.stringify(compositeDeps, null, 2));
+
+      // fetching package own deps
+      return innerCommon.getLocalPackagesDeps();
+    })
+
+
+    .then((localPkgDepsIn) => {
+      // storing
+      localPkgDeps = localPkgDepsIn;
+
+      tools.logInfo(`Found local packages deps : `);
+      console.log(JSON.stringify(localPkgDeps, null, 2));
+
+      // fetching local package composite
+      return innerCommon.getLocalPackagesCompositeDeps();
+    })
+
+    // Get last known working build dependencies from DEVOPS metadata, including snapshot releases
+    .then((localPkgCompositeDepsIn) => {
+      // storing
+      localPkgCompositeDeps = localPkgCompositeDepsIn;
+
+      return metadataUtils.package.getPackagesDeps('packages');
+    })
+
+    .then((depsMetadata) => {
+      return innerCommon.getRemappedDeps(depsMetadata, localPkgCompositeDeps);
+    })
+
+    .then((remappedLocalPkgCompositeDeps) => {
+      // fetching extra dependencies on project if any
+      let prjDeps = {};
+
+      if (prj) {
+        const prjJsonFile = path.join(process.cwd(), prj.folder, 'dependencies-base.json');
+        prjDeps = tools.getJsonFileContent(prjJsonFile) || {};
+      }
+
+      const fixedDeps = configUtils.global.getConfig().npm.fixedDependencies;
+
+      if (pkg.build && pkg.build.ownDepsOnly) {
+        return innerCommon.installDeps({ ...remappedLocalPkgCompositeDeps, ...localPkgDeps, ...fixedDeps});
+
+      } else {
+        return innerCommon.installDeps({ ...remappedLocalPkgCompositeDeps, ...localPkgDeps, ...prjDeps, ...compositeDeps, ...fixedDeps });
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/install/projects.js

@@ -0,0 +1,76 @@
+'use strict';
+
+// GLOBAL
+const execa = require('execa');
+const path = require('path');
+
+// LOCAL
+const tools = require('../../utils/tools');
+const configUtils = require('../config/config-utils');
+
+// INNER MODULES
+const innerCommon = require('./common');
+const innerCompositeCore = require('./composite-core');
+
+// FETCH ARGS
+const { dryRun, skipInstall } = tools.getArgs();
+
+
+
+const getDeps = module.exports.getDeps = (prj, envTarget, compositeType) => {
+  return Promise.resolve()
+    .then(() => {
+      return metadataUtils.appEnvs.getMetadata(prj);
+    })
+    .then((envsMetadata) => {
+      return innerCompositeCore.getDeps(
+        prj.folder,
+        envTarget,
+        compositeType,
+        prj.build && prj.build.prevSnapshotEnabled,
+        envsMetadata
+      );
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+module.exports.installDeps = (prj, envTarget, compositeType) => {
+  let finalDeps, compositeDeps;
+
+  return Promise.resolve()
+    .then(() => {
+      return getDeps(prj, envTarget, compositeType);
+    })
+    .then((deps) => {
+      // storing compositeDeps
+      compositeDeps = deps;
+    })
+
+    .then(() => {
+      return innerCommon.getLocalProjectFixedDeps(prj);
+    })
+
+    .then((prjFixedDeps) => {
+      // storing for archiving
+      finalDeps = { ...compositeDeps, ...prjFixedDeps };
+
+      // fetching extra dependencies on project
+      const prjBaseJsonFile = path.join(process.cwd(), prj.folder, 'dependencies-base.json');
+      const prjBaseDeps = tools.getJsonFileContent(prjBaseJsonFile) || {};
+      const fixedDeps = configUtils.global.getConfig().npm.fixedDependencies;
+
+      return innerCommon.installDeps({ ...prjBaseDeps, ...compositeDeps, ...prjFixedDeps, ...fixedDeps });
+    })
+
+    .then(() => {
+      // returning only the composite deps found, only those will be stored in the metadata
+      return finalDeps;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/install/{remote.js → remotes.js}

@@ -10,30 +10,13 @@ const metadataUtils = require('../metadata/metadata-utils');
 
 // INNER MODULES
 const innerCommon = require('./common');
+const innerCompositeCore = require('./composite-core');
 
 // FETCH ARGS
 const { dryRun } = tools.getArgs();
 
 
-module.exports.installDeps = (pkg, isMaster) => {
-  tools.logTitle('Remote dependencies installation');
-
-  return Promise.resolve()
-    .then(() => {
-      if (pkg) {
-        return pkgInstall(pkg, isMaster);
-      } else {
-        return allPkgInstall(isMaster);
-      }
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-const allPkgInstall = (isMaster) => {
+const allPkgInstall = (envTarget, compositeType) => {
   return Promise.resolve()
 
     // getting packages to be remotely installed
@@ -52,7 +35,7 @@ const allPkgInstall = (isMaster) => {
     .then((packages) => Promise.resolve().then(() => {
       return packages.reduce((promise, pkg) => {
         return promise.then(() => (
-          pkgInstall(pkg, isMaster)
+          pkgInstall(pkg, envTarget, compositeType)
         ));
       }, Promise.resolve());
     }))
@@ -62,22 +45,30 @@ const allPkgInstall = (isMaster) => {
     });
 }
 
-
-
-const pkgInstall = (pkg, isMaster) => {
+const pkgInstall = (pkg, envTarget, compositeType) => {
   tools.logTitle(`Processing installation for : ${pkg.name}`);
 
-  var outputDeps;
+  let finalDeps;
 
   return Promise.resolve()
     .then(() => {
       // fetching deps from dependencies base and composite if any
-      return getDeps(pkg, isMaster);
+      return getDeps(pkg, envTarget, compositeType);
     })
-
-    .then((deps) => {
+    .then((compositeDeps) => {
       // storing for later exports
-      outputDeps = deps;
+      finalDeps = compositeDeps;
+
+      // getting base deps (3rd parties)
+      let baseDeps = {}, deps;
+
+      const depsBaseJsonFile = path.join(pkg.paths.pkgRootDirectory, 'dependencies-base.json');
+      if (tools.isFileExists(depsBaseJsonFile)) {
+        baseDeps = tools.getJsonFileContent(depsBaseJsonFile);
+      }
+
+      // merging base+composite
+      deps = { ...baseDeps, ...compositeDeps };
 
       // updating package json file before installation
       const pkgJsonFile = path.resolve(pkg.paths.pkgRootDirectory, 'package.json');
@@ -105,7 +96,8 @@ const pkgInstall = (pkg, isMaster) => {
     })
 
     .then(() => {
-      return outputDeps;
+      // returning only the composite deps found, only those will be stored in the metadata
+      return finalDeps;
     })
 
     .catch((e) => {
@@ -122,42 +114,45 @@ const pkgInstall = (pkg, isMaster) => {
 
         tools.writeJsonFileSync(pkgJsonFile, pkgJson);
       }
-      return outputDeps;
+      return finalDeps;
     });
 }
 
 
-const getDeps = (pkg, isMaster) => {
+const getDeps = module.exports.getDeps = (pkg, envTarget, compositeType) => {
   return Promise.resolve()
     .then(() => {
-      if (isMaster) {
-        return metadataUtils.package.getPackagesDeps('packagesLatestTag');
-      } else {
-        return metadataUtils.package.getPackagesDeps('packages');
-      }
+      return metadataUtils.packageEnvs.getMetadata(pkg);
+    })
+    .then((envsMetadata) => {
+      return innerCompositeCore.getCompositeDeps(
+        pkg.paths.pkgFromRoot,
+        envTarget,
+        compositeType,
+        pkg.build && pkg.build.prevSnapshotEnabled,
+        envsMetadata
+      );
     })
-    // fetching base dependencies
-    .then((depsMetadata) => {
-      let depsBase = {};
 
-      const depsBaseJsonFile = path.join(pkg.paths.pkgRootDirectory, 'dependencies-base.json');
-      if (tools.isFileExists(depsBaseJsonFile)) {
-        depsBase = tools.getJsonFileContent(depsBaseJsonFile);
-      }
+    .catch((e) => {
+      throw e;
+    })
+}
 
-      let depsComposite = {};
 
-      const depsCompositeJsonFile = path.join(pkg.paths.pkgRootDirectory, 'dependencies-composite.json');
-      if (tools.isFileExists(depsCompositeJsonFile)) {
-        depsComposite = tools.getJsonFileContent(depsCompositeJsonFile);
-      }
+module.exports.installDeps = (pkg, envTarget, compositeType) => {
+  tools.logTitle('Remote dependencies installation');
 
-      return innerCommon.getRemappedDeps(depsMetadata, { ...depsBase, ...depsComposite});
+  return Promise.resolve()
+    .then(() => {
+      if (pkg) {
+        return pkgInstall(pkg, envTarget, compositeType);
+      } else {
+        return allPkgInstall(envTarget, compositeType);
+      }
     })
 
     .catch((e) => {
       throw e;
     })
 }
-
-

package/scripts/csdr/metadata/app-envs.js

@@ -73,46 +73,7 @@ const storeMetadata = (project, newVersion, metadata, envTarget) => {
 
 
 
-const envsMetadataToTable = (metadata) => {
-  return Promise.resolve()
-    .then(() => {
-      let content = '';
-      content += '<h3>Environment status</h3>';
-      content += '<table><thead><tr>';
-      content += '<th>ENV</th>';
-      content += '<th>VERSION</th>';
-      content += '<th>Release date</th>';
-      content += '</tr></thead>';
-      content += '<tbody>';
-
-      Object.entries(metadata).forEach((env) => {
-        content += '<tr>';
-        content += `<td>${env[0]}</td>`
-        content += `<td>${env[1].version}</td>`
-        content += `<td>${env[1].releaseDate}</td>`
-        content += '</tr>';
-
-        console.log(`ENVS status : ${env[0]} - ${env[1].version} --> ${env[1].releaseDate}`);
-      });
-
-      content += '</tbody>';
-      content += '</table>';
-
-      tools.logSuccess();
-
-      // return sanitizeHtml(content);
-      return content;
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-
 module.exports = {
   getMetadata,
   storeMetadata,
-  envsMetadataToTable,
 }

package/scripts/csdr/metadata/app-history.js

@@ -336,71 +336,6 @@ const generateDiffReport = (project, newVersion, isSupportBranch, envTarget, fro
 }
 
 
-
-
-const historyMetadataToTable = (metadata) => {
-  tools.logTitle('Generating table from metadata...');
-
-  const iSSUES_MANAGER_HOST = configUtils.global.getConfigOptions().iSSUES_MANAGER_HOST;
-
-  var content;
-
-  if (!metadata.versions) {
-    tools.logWarning('WARNING: no content found');
-    return content;
-  }
-
-  content = '';
-  content += '<h3>MyWorkplace MAJOR versions history</h3>';
-  content += '<table><thead><tr>';
-  content += '<th>ENV</th>';
-  content += '<th>VERSION</th>';
-  content += '<th>CONTENT</th>';
-  content += '</tr></thead>';
-  content += '<tbody>';
-
-  metadata.versions.reverse().forEach((item) => {
-    content += '<tr>';
-    content += `<td><strong>${item.envTarget}</strong></td>`
-    content += `<td><strong>${item.name}</strong></td>`
-    content += '<td>';
-    if (!item.diffs || item.diffs.length === 0) {
-      content += 'N/A';
-    } else {
-      item.diffs.forEach((diffItem) => {
-        content += `<strong>${diffItem.name}</strong> : from ${diffItem.old} to ${diffItem.new}`
-        content += `<hr />`
-        if (diffItem.gitMetadata.length === 0) {
-          content += 'N/A';
-        } else {
-          diffItem.gitMetadata.forEach((gitCommits) => {
-            gitCommits.forEach((gitCommit) => {
-              if (gitCommit.issue === '') {
-                content += `N/A - ${gitCommit.subject}`;
-              } else {
-                content += `<a href="${iSSUES_MANAGER_HOST}${gitCommit.issue}">${gitCommit.issue}</a> - ${gitCommit.subject}`;
-              }
-              content += `<br />`;
-            })
-          })
-        }
-        content += `<br />`;
-      })
-    }
-    content += '</td>';
-    content += '</tr>';
-  })
-  content += '</tbody>';
-  content += '</table>';
-
-  tools.logSuccess();
-
-  // return sanitizeHtml(content);
-  return content;
-}
-
-
-
 const flattenDiffMetadata = (metadata) => {
   return Promise.resolve()
     .then(() => {
@@ -437,7 +372,6 @@ module.exports.getMetadata = getMetadata;
 module.exports.storeMetadata = storeMetadata;
 module.exports.getDiffBetweenMajors = getDiffBetweenMajors;
 module.exports.generateDiffReport = generateDiffReport;
-module.exports.historyMetadataToTable = historyMetadataToTable;
 module.exports.flattenDiffMetadata = flattenDiffMetadata;
 module.exports.flatDiffMetadataToMessage = flatDiffMetadataToMessage;
 module.exports.getDiffBetweenBuildVersions = getDiffBetweenBuildVersions;

package/scripts/csdr/metadata/app-versions.js

@@ -13,7 +13,7 @@ const { dryRun } = tools.getArgs();
 
 
 
-const getMetadata = (project) => {
+module.exports.getMetadata = (project) => {
   const DEVOPS_METADATA_PATH = configUtils.global.getConfigOptions().DEVOPS_METADATA_PATH;
 
   return Promise.resolve()
@@ -31,7 +31,7 @@ const getMetadata = (project) => {
 
 
 
-const storeMetadata = (project, newVersion, envTarget) => {
+module.exports.storeMetadata = (project, newVersion, envTarget) => {
   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,8 +61,6 @@ const storeMetadata = (project, newVersion, envTarget) => {
 
       generatedMetadata.versions = versions;
 
-      // console.log(JSON.stringify(generatedMetadata, null, 4));
-
       if (!dryRun) {
         tools.writeJsonFileSync(metadataFile, generatedMetadata);
       }
@@ -76,11 +74,3 @@ const storeMetadata = (project, newVersion, envTarget) => {
       throw e;
     })
 }
-
-
-
-
-module.exports = {
-  getMetadata,
-  storeMetadata,
-}

package/scripts/csdr/metadata/app.js

@@ -7,7 +7,7 @@ const moment = require('moment');
 // LOCAL
 const tools = require('../../utils/tools');
 const configUtils = require('../config/config-utils');
-const compositeUtils = require('../install/composite-utils');
+const installUtils = require('../install/install-utils');
 const versionUtils = require('../version/version-utils');
 
 // FETCH ARGS
@@ -86,19 +86,39 @@ const storeMetadataAssets = (project, newVersion, packagesDeps, historyMetadata,
   tools.logTitle('Storing app assets metadata');
 
   return Promise.resolve()
+    // getting remotes entries
     .then(() => {
+      let remotes = [];
+
+      if (project.hasRemotes) {
+        remotes = configUtils.packages.getCsdrRemotePackages().filter((p) => {
+                          return p.hostAppName = project.name
+                        }).map((p) => {
+                          return { name: p.name, npmPkg: p.npmPkg }
+                        });
+        if (remotes) {
+          remotes = tools.sortArray(remotes, 'name');
+        }
+      }
+
+      return remotes;
+    })
+
+    // storing metadata file
+    .then((remotes) => {
       tools.logInfo('Storing app metadata into project assets');
 
       const appMetadata = {
         appVersion: newVersion,
         appReleaseDate: appReleaseDate,
         appInfos: appInfos,
-        metadata: packagesDeps
+        metadata: packagesDeps,
+        remotes: remotes,
       };
 
       const metadataFile = path.join(project.folder, 'src', 'assets', 'app-metadata.json');
 
-      console.log(`Creating ${metadataFile}`);
+      tools.logInfo(`Creating ${metadataFile}`);
       console.log(appMetadata);
 
       if (!dryRun) {
@@ -112,7 +132,7 @@ const storeMetadataAssets = (project, newVersion, packagesDeps, historyMetadata,
 
       const metadataFile = path.join(project.folder, 'src', 'assets', 'app-metadata-history.json');
 
-      console.log(`Creating ${metadataFile}`);
+      tools.logInfo(`Creating ${metadataFile}`);
 
       if (!dryRun && envTarget && envTarget !== 'DEV') {
         return tools.writeJsonFileSync(metadataFile, historyMetadata);
@@ -131,7 +151,7 @@ const storeMetadataAssetsStandAlone = () => {
 
   // getting project
   const prj = configUtils.projects.getProject();
-  let currentVersion;
+  let currentVersion, packageDeps, remotes = [];
 
   return Promise.resolve()
     // getting current app version
@@ -144,23 +164,43 @@ const storeMetadataAssetsStandAlone = () => {
 
     // getting packages composite deps version
     .then(() => {
-      return compositeUtils.getDeps(prj);
+      return installUtils.projects.getDeps(prj);
+    })
+    .then((deps) => {
+      packageDeps = deps;
+    })
+
+
+    // getting remotes entries
+    .then(() => {
+      if (prj.hasRemotes) {
+        remotes = configUtils.packages.getCsdrRemotePackages().filter((p) => {
+                          return p.hostAppName = prj.name
+                        }).map((p) => {
+                          return { name: p.name, npmPkg: p.npmPkg }
+                        });
+        if (remotes) {
+          remotes = tools.sortArray(remotes, 'name');
+        }
+      }
     })
 
+
     // storing metadata
-    .then((deps) => {
+    .then(() => {
       tools.logInfo('Storing app metadata into project assets');
 
       const appMetadata = {
         appVersion: currentVersion,
         appReleaseDate: moment(new Date()).format("DD/MM/YYYY HH:mm"),
         appInfos: null,
-        metadata: deps
+        metadata: packageDeps,
+        remotes: remotes
       };
 
       const metadataFile = path.join(prj.folder, 'src', 'assets', 'app-metadata.json');
 
-      console.log(`Creating ${metadataFile}`);
+      tools.logInfo(`Creating ${metadataFile}`);
       console.log(appMetadata);
 
       if (!dryRun) {