@eui/tools 4.21.10 → 5.0.0-rc.12

package/scripts/csdr/install/composite-core.js

@@ -0,0 +1,256 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// LOCAL
+const tools = require('../../utils/tools');
+const metadataUtils = require('../metadata/metadata-utils');
+
+// INNER MODULES
+const innerCommon = require('./common');
+
+
+
+
+const getDeps_DEV = (compositeDeps, prevSnapshotEnabled) => {
+  return Promise.resolve()
+    .then(() => {
+      if (prevSnapshotEnabled) {
+        tools.logInfo('project has prevSnapshot enabled, getting deps list from prevSnapshotsTag');
+        return metadataUtils.package.getPackagesDeps('packagesPrevSnapshotsTag');
+      } else {
+        tools.logInfo('getting project deps from snapshots metadata list');
+        return metadataUtils.package.getPackagesDeps('packages');
+      }
+    })
+
+    // Re-mapping the dependencies found against their max "carret" versions found in the base dependencies defs in the project
+    .then((metadataDeps) => {
+      return innerCommon.getRemappedDeps(metadataDeps, compositeDeps);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+const getDeps_TST = (compositeDeps, prevSnapshotEnabled) => {
+  return Promise.resolve()
+    .then(() => {
+      if (prevSnapshotEnabled) {
+        tools.logInfo('project has prevSnapshot enabled, getting deps list from prevTag');
+        return metadataUtils.package.getPackagesDeps('packagesPrevTag');
+      } else {
+        tools.logInfo('getting project deps from packagesLatest metadata list');
+        return metadataUtils.package.getPackagesDeps('packagesLatestTag');
+      }
+    })
+
+    // Re-mapping the dependencies found against their max "carret" versions found in the base dependencies defs in the project
+    .then((metadataDeps) => {
+      return innerCommon.getRemappedDeps(metadataDeps, compositeDeps);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+
+const getCompositeDepsByEnv = (compositePath, envTarget, compositeType, envsMetadata, prevEnv, currentEnv) => {
+
+  let prevEnvDeps = {}, currentEnvDeps = {};
+
+  if (envsMetadata[prevEnv]) {
+    prevEnvDeps = envsMetadata[prevEnv].dependencies;
+  } else {
+    throw new Error(`
+      ${prevEnv} dependencies not found for ${currentEnv} dependencies fetch, ensure that the project/remote has been delivered to a previous environment first
+    `);
+  }
+
+  if (envsMetadata[currentEnv]) {
+    currentEnvDeps = envsMetadata[currentEnv].dependencies;
+  }
+
+
+  // if default composite type then we iterate over all detected composite files by env
+  if (compositeType === 'DEFAULT') {
+    return Promise.resolve()
+    .then(() => {
+      tools.logTitle('Processing accumulated composites for ALL composite types');
+      const filesByEnv = tools.getFiles(compositePath).filter(f => f.startsWith(`dependencies-composite-${envTarget}` ));
+      var returnedDeps = {};
+
+      filesByEnv.forEach((f) => {
+        tools.logInfo(`Parsing : ${f}`);
+        const compositeFile = path.join(process.cwd(), compositePath, f);
+        const fileDeps = tools.getJsonFileContent(compositeFile).lockedDependencies || {};
+        console.log(JSON.stringify(fileDeps, null, 2));
+        returnedDeps = { ...returnedDeps, ...fileDeps};
+      });
+
+      return { ...prevEnvDeps, ...returnedDeps };
+    })
+    .catch((e) => {
+      throw e;
+    })
+
+  // if particular composite type is provided, the dependencies are taken only from this one
+  } else {
+    return Promise.resolve()
+    .then(() => {
+      tools.logTitle(`Processing dependencies for composite type : ${compositeType}`);
+      const compositeFile = path.join(process.cwd(), compositePath, `dependencies-composite-${envTarget}-${compositeType}.json`);
+      const fileDeps = tools.getJsonFileContent(compositeFile).lockedDependencies || {};
+      console.log(JSON.stringify(fileDeps, null, 2));
+      return { ...currentEnvDeps, ...fileDeps };
+    })
+    .catch((e) => {
+      throw e;
+    })
+  }
+}
+
+
+
+
+
+
+
+
+module.exports.getCompositeDeps = (
+  compositePath,
+  envTarget = 'DEV',
+  compositeType = 'DEFAULT',
+  prevSnapshotEnabled = false,
+  envsMetadata
+) => {
+
+  tools.logInfo(`Processing installation at : ${compositePath} for env: ${envTarget} - compositeType: ${compositeType}`);
+
+  return Promise.resolve()
+    // getting root composite - dependencies-composite.json content
+    .then(() => {
+      const compositeJsonFile = path.join(process.cwd(), compositePath, 'dependencies-composite.json');
+      return tools.getJsonFileContent(compositeJsonFile) || {};
+    })
+
+    // getting env specific composite with compositeType if provided
+    .then((compositeDeps) => {
+      /**
+      * For DEV target, we take the outermost known versions of the packages,
+      * including : SNAPSHOTS & LATEST
+      */
+      if (envTarget === 'DEV') {
+        return getDeps_DEV(compositeDeps, prevSnapshotEnabled);
+      }
+
+
+      /**
+      * For TST target, we take only the LATEST know versions of the packages,
+      * including : LATEST
+      */
+      if (envTarget === 'TST') {
+        return getDeps_TST(compositeDeps, prevSnapshotEnabled);
+      }
+
+
+      /**
+      * For INT target, the base versions of packages is
+      * Default : dependencies of LATEST TST known composite
+      * overridden by : INT composite - locked dependencies to declare the deps that are staying on the TST env and
+      * will not go further for the moment.
+      */
+      if (envTarget === 'INT') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'TST', 'INT'
+        );
+      }
+
+
+     /**
+      * For ACC, the base versions of packages is
+      * Default : dependencies of LATEST INT known composite
+      * overridden by : lockedDependencies if any
+      */
+      if (envTarget === 'ACC') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'INT', 'ACC'
+        );
+      }
+
+
+     /**
+      * For PROD target, the base versions of packages is
+      * Default : PROD respective composite
+      */
+      if (envTarget === 'PROD') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'TRN', 'PROD'
+        );
+      }
+
+
+     /**
+      * For TRN, the base versions of packages is
+      * Default : dependencies of LATEST PROD known composite
+      * overridden by : hotfixDependencies if any
+      */
+      if (envTarget === 'TRN') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'ACC', 'TRN'
+        );
+      }
+
+
+      /**
+      * For DLT, the base versions of packages is
+      * Default : dependencies of LATEST ACC known composite
+      */
+      if (envTarget === 'DLT') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'ACC', 'DLT'
+        );
+      }
+    })
+
+    // Finally the re-mapped env-based composite of dependencies is returned
+    .then((finalDeps) => {
+      tools.logInfo('Packages composite found for target : ');
+      console.log(finalDeps);
+
+      // returning the composite packages found
+      return finalDeps;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+

package/scripts/csdr/install/install-utils.js

@@ -5,12 +5,16 @@ const innerBuildApp = require('./build-app');
 const innerBuildPackage = require('./build-package');
 const innerLocalDev = require('./local-dev');
 const innerCommon = require('./common');
-const innerCompositeUtils = require('./composite-utils');
-const innerRemote = require('./remote');
+const innerProjects = require('./projects');
+const innerRemotes = require('./remotes');
+const innerPackages = require('./packages');
+const innerCompositeCore = require('./composite-core');
 
 module.exports.buildApp = innerBuildApp;
 module.exports.buildPackage = innerBuildPackage;
 module.exports.localDev = innerLocalDev;
 module.exports.common = innerCommon;
-module.exports.compositeUtils = innerCompositeUtils;
-module.exports.remote = innerRemote;
+module.exports.projects = innerProjects;
+module.exports.remotes = innerRemotes;
+module.exports.packages = innerPackages;
+module.exports.compositeCore = innerCompositeCore;

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

@@ -11,7 +11,7 @@ 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();
@@ -100,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, envTarget) => {
-  tools.logTitle('Remote dependencies installation');
-
-  return Promise.resolve()
-    .then(() => {
-      if (pkg) {
-        return pkgInstall(pkg, isMaster, envTarget);
-      } else {
-        return allPkgInstall(isMaster, envTarget);
-      }
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-const allPkgInstall = (isMaster, envTarget) => {
+const allPkgInstall = (envTarget, compositeType) => {
   return Promise.resolve()
 
     // getting packages to be remotely installed
@@ -52,7 +35,7 @@ const allPkgInstall = (isMaster, envTarget) => {
     .then((packages) => Promise.resolve().then(() => {
       return packages.reduce((promise, pkg) => {
         return promise.then(() => (
-          pkgInstall(pkg, isMaster, envTarget)
+          pkgInstall(pkg, envTarget, compositeType)
         ));
       }, Promise.resolve());
     }))
@@ -62,22 +45,30 @@ const allPkgInstall = (isMaster, envTarget) => {
     });
 }
 
-
-
-const pkgInstall = (pkg, isMaster, envTarget) => {
+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, envTarget);
+      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, envTarget) => {
     })
 
     .then(() => {
-      return outputDeps;
+      // returning only the composite deps found, only those will be stored in the metadata
+      return finalDeps;
     })
 
     .catch((e) => {
@@ -122,46 +114,45 @@ const pkgInstall = (pkg, isMaster, envTarget) => {
 
         tools.writeJsonFileSync(pkgJsonFile, pkgJson);
       }
-      return outputDeps;
+      return finalDeps;
     });
 }
 
 
-const getDeps = (pkg, isMaster, envTarget = null) => {
+const getDeps = module.exports.getDeps = (pkg, envTarget, compositeType) => {
   return Promise.resolve()
     .then(() => {
-      if (isMaster || envTarget !== null) {
-        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);
-      }
 
-      let depsComposite = {};
+    .catch((e) => {
+      throw e;
+    })
+}
 
-      const depsCompositeJsonFile = path.join(pkg.paths.pkgRootDirectory, 'dependencies-composite.json');
-      if (tools.isFileExists(depsCompositeJsonFile)) {
-        depsComposite = tools.getJsonFileContent(depsCompositeJsonFile);
-      }
 
-      // TODO - handle dependencies composite per environment => one bamboo plan for each envs to be defined
-      // if (envTarget) {
-      // }
+module.exports.installDeps = (pkg, envTarget, compositeType) => {
+  tools.logTitle('Remote dependencies installation');
 
-      return innerCommon.getRemappedDeps(depsMetadata, { ...depsBase, ...depsComposite}, isMaster || envTarget !== null);
+  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,
 }