@eui/tools 5.3.90 → 6.1.1

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

@@ -1,9 +1,5 @@
 'use strict';
 
-// GLOBAL
-const execa = require('execa');
-const path = require('path');
-
 // LOCAL
 const tools = require('../../utils/tools');
 const configUtils = require('../config/config-utils');
@@ -12,67 +8,85 @@ const metadataUtils = require('../metadata/metadata-utils');
 // INNER MODULES
 const innerCommon = require('./common');
 const innerRemotes = require('./remotes');
+const innerProjects = require('./projects');
+const innerPackages = require('./packages');
+
+module.exports.installPackage = (pkgName) => {
+
+  const pkg = configUtils.packages.getPackage(pkgName, false, true);
 
-// FETCH ARGS
-const { dryRun, skipInstall } = tools.getArgs();
+  return Promise.resolve()
+    .then(() => {
+      return metadataUtils.common.cloneMetadataRepo(true);
+    })
+
+    .then(() => {
+      if (pkg.remote) {
+        return innerRemotes.installDeps(pkg);
+      } else {
+        return innerPackages.installDeps(null, pkg);
+      }
+    })
 
+    .catch((e) => {
+      throw e;
+    })
+}
 
 
 
-module.exports.install = (pkg) => {
-  let packagesDeps, packagesCompositeDeps, projectsDeps, projectsFixedDeps, finalDeps, snapshotsMetadata;
+module.exports.install = () => {
+  let finalDeps = {}, resolvedDeps = {}, remoteDeps = {};
 
   return Promise.resolve()
 
-    // cloning devops metadata repo
     .then(() => {
       return metadataUtils.common.cloneMetadataRepo(true);
     })
 
-    // getting packages snapshot deps metadata and storing
+    // getting internal packages deps - cloned locally
     .then(() => {
-      return metadataUtils.package.getPackagesDeps('packages');
+      return innerPackages.getLocalPackagesDeps();
     })
-    .then((depsMetadata) => {
-      snapshotsMetadata = depsMetadata;
+    .then((deps) => {
+      resolvedDeps = {...resolvedDeps, ...deps};
     })
 
-    // getting internal packages deps - cloned locally
+    // Getting internal packages deps - project cloned locally
     .then(() => {
-      return innerCommon.getLocalPackagesDeps();
+      return innerPackages.getLocalPackagesCompositeDeps();
     })
-
-
-
-    // Getting internal packages deps - project cloned locally
-    .then((pkgDeps) => {
-      // storing
-      packagesDeps = pkgDeps;
-
-      return innerCommon.getLocalPackagesCompositeDeps();
+    .then((deps) => {
+      resolvedDeps = {...resolvedDeps, ...deps};
     })
 
     // Getting internal packages deps - project cloned locally
-    .then((pkgCompositeDeps) => {
-      // storing
-      packagesCompositeDeps = pkgCompositeDeps;
-
-      return innerCommon.getLocalProjectsDeps(snapshotsMetadata);
+    .then(() => {
+      return innerProjects.getLocalProjectsDeps();
     })
-    .then((prjDeps) => {
-      projectsDeps = prjDeps;
+    .then((deps) => {
+      resolvedDeps = {...resolvedDeps, ...deps};
     })
 
-
     // getting internal projects fixed deps if any
     .then(() => {
-      return innerCommon.getLocalProjectsFixedDeps();
+      return innerProjects.getLocalProjectsFixedDeps();
+    })
+    .then((deps) => {
+      resolvedDeps = {...resolvedDeps, ...deps};
+    })
+
+    // getting internal projects remotes deps if any
+    .then(() => {
+      return innerProjects.getLocalProjectsRemoteDeps();
     })
-    .then((prjFixedDeps) => {
-      projectsFixedDeps = prjFixedDeps;
+    .then((deps) => {
+      remoteDeps = deps; // storing for remote import usage
+      resolvedDeps = {...resolvedDeps, ...deps};
     })
 
 
+
     // Get last known working build dependencies from DEVOPS metadata, including snapshot releases
     .then(() => {
       return metadataUtils.package.getPackagesDeps('packages');
@@ -84,13 +98,10 @@ module.exports.install = (pkg) => {
 
       const fixedDeps = configUtils.global.getConfig().npm.fixedDependencies;
 
-      const configDeps = { ...packagesDeps, ...packagesCompositeDeps, ...projectsDeps, ...projectsFixedDeps, ...fixedDeps };
+      const configDeps = { ...resolvedDeps, ...fixedDeps };
 
-      tools.logInfo('Package deps found : ');
-      console.log(packagesDeps);
-
-      tools.logInfo('Packages composite deps found : ');
-      console.log(packagesCompositeDeps);
+      tools.logInfo('Accumulated dependencies found : ');
+      console.log(configDeps);
 
       return innerCommon.getRemappedDeps(depsMetadata, configDeps, false);
     })
@@ -100,19 +111,17 @@ module.exports.install = (pkg) => {
     .then((updatedDeps) => {
       finalDeps = updatedDeps;
 
-      if (!pkg) {
-        return innerCommon.installDeps(updatedDeps);
-      }
+      return innerCommon.installDeps(updatedDeps);
     })
 
     // Import remotes into local projects
     .then(() => {
-      return innerCommon.importLocalProjectsRemotes(finalDeps);
+      return innerProjects.importLocalProjectsRemotes(remoteDeps);
     })
 
     // checking remotes
     .then(() => {
-      return innerRemotes.installDeps(pkg);
+      return innerRemotes.installDeps();
     })
 
     .then(() => {

package/scripts/csdr/install/packages.js

@@ -13,6 +13,186 @@ const metadataUtils = require('../metadata/metadata-utils');
 const innerCommon = require('./common');
 const innerProjects = require('./projects');
 
+// FETCH ARGS
+const { skipLocalPackagesDeps } = tools.getArgs();
+
+
+
+
+const getLocalPackageDeps = (pkg) => {
+  let pkgJsonFile;
+
+  if (pkg.parent) {
+    return {};
+  } else {
+    if (pkg.child) {
+      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'package.json');
+    } else {
+      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'package.json');
+    }
+  }
+
+  return tools.getJsonFileContent(pkgJsonFile).dependencies || {};
+}
+
+
+const getLocalPackagesDeps = module.exports.getLocalPackagesDeps = () => {
+  const packages = configUtils.packages.getPackages();
+  let deps = {};
+
+  packages.forEach(p => {
+    const pkgDeps = getLocalPackageDeps(p);
+
+    tools.logInfo(`Getting local dependencies for ${p.name}`);
+    console.log(JSON.stringify(pkgDeps, null, 2));
+
+    const pdeps = Object.keys(pkgDeps)
+      .reduce((acc, k) => {
+        if (k.indexOf('@eui') !== -1 ) {
+          if (k.indexOf('@eui/ecl') !== -1 ||
+              k.indexOf('@eui/styles-base') !== -1
+          ) {
+            acc[k] = pkgDeps[k];
+          }
+        } else {
+          acc[k] = pkgDeps[k];
+        }
+        return acc;
+      }, {});
+
+    deps = { ...deps, ...pdeps };
+  })
+
+  return deps;
+}
+
+
+const getLocalPackageCompositeDeps = (pkg) => {
+  let pkgJsonFile;
+
+  if (!skipLocalPackagesDeps) {
+    if (pkg.child) {
+      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'dependencies-composite.json');
+    } else {
+      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'dependencies-composite.json');
+    }
+
+    if (tools.isFileExists(pkgJsonFile)) {
+      tools.logInfo(`found ${pkgJsonFile}, parsing...`);
+    }
+
+    return tools.getJsonFileContent(pkgJsonFile) || {};
+
+  } else {
+    tools.logInfo('Skipping gathering local packages composite deps');
+
+    return {};
+  }
+}
+
+
+const getLocalPackagesCompositeDeps = module.exports.getLocalPackagesCompositeDeps = () => {
+  tools.logTitle('Parsing composite deps for local packages');
+
+  let deps = {};
+
+  // getting locally mounted packages, don't take into account remotely installed packages (elements remote)
+  const packages = configUtils.packages.getPackages().filter((p) => {
+    return !p.paths.remoteNodeModules;
+  });
+
+  packages.forEach(p => {
+    tools.logInfo(`Parsing package : ${p.name}`);
+
+    // getting the package composite if any
+    const compositeDeps = getLocalPackageCompositeDeps(p);
+
+    deps = { ...deps, ...compositeDeps };
+
+    tools.logInfo('Deps found : ');
+    console.log(deps);
+  })
+
+  return deps;
+}
+
+
+const getLocalPackageBaseDeps = (pkg) => {
+  let pkgJsonFile;
+
+  if (!skipLocalPackagesDeps) {
+    if (pkg.child) {
+      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'dependencies-base.json');
+    } else {
+      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'dependencies-base.json');
+    }
+
+    if (tools.isFileExists(pkgJsonFile)) {
+      tools.logInfo(`found ${pkgJsonFile}, parsing...`);
+    }
+
+    return tools.getJsonFileContent(pkgJsonFile) || {};
+
+  } else {
+    tools.logInfo('Skipping gathering local packages base deps');
+
+    return {};
+  }
+}
+
+
+
+const getLocalPackagesBaseDeps = module.exports.getLocalPackagesBaseDeps = () => {
+  tools.logTitle('Parsing base deps for local packages');
+
+  let deps = {};
+
+  // getting locally mounted packages, don't take into account remotely installed packages (elements remote)
+  const packages = configUtils.packages.getPackages().filter((p) => {
+    return !p.paths.remoteNodeModules;
+  });
+
+  packages.forEach(p => {
+    tools.logInfo(`Parsing package : ${p.name}`);
+
+    // getting the package base if any
+    const baseDeps = getLocalPackageBaseDeps(p);
+
+    deps = { ...deps, ...baseDeps };
+
+    tools.logInfo('Deps found : ');
+    console.log(deps);
+  })
+
+  return deps;
+}
+
+
+module.exports.getLocalPackagesCompositeDepsRemapped = () => {
+  return Promise.resolve()
+    .then(() => {
+      return metadataUtils.package.getPackagesDeps('packages');
+    })
+
+    .then((depsMetadata) => {
+      const compositeDeps = getLocalPackagesCompositeDeps();
+
+      return innerCommon.getRemappedDeps(depsMetadata, compositeDeps, false);
+    })
+
+    .then((remappedDeps) => {
+      tools.logInfo('Remapped deps : ');
+
+      console.log(remappedDeps);
+
+      return remappedDeps;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
 
 module.exports.installDeps = (prj, pkg, isMaster) => {
   let compositeDeps, localPkgDeps, localPkgCompositeDeps, remappedDeps, localPkgBaseDeps;
@@ -38,7 +218,7 @@ module.exports.installDeps = (prj, pkg, isMaster) => {
       console.log(JSON.stringify(compositeDeps, null, 2));
 
       // fetching package own deps
-      return innerCommon.getLocalPackagesDeps();
+      return getLocalPackagesDeps();
     })
 
 
@@ -50,7 +230,7 @@ module.exports.installDeps = (prj, pkg, isMaster) => {
       console.log(JSON.stringify(localPkgDeps, null, 2));
 
       // fetching local package composite
-      return innerCommon.getLocalPackagesCompositeDeps();
+      return getLocalPackagesCompositeDeps();
     })
 
     // Get last known working build dependencies from DEVOPS metadata, including snapshot releases
@@ -69,7 +249,7 @@ module.exports.installDeps = (prj, pkg, isMaster) => {
       // storing
       remappedDeps = remappedDepsIn;
 
-      return innerCommon.getLocalPackagesBaseDeps();
+      return getLocalPackagesBaseDeps();
     })
 
     .then((localPkgBaseDepsIn) => {

package/scripts/csdr/install/projects.js

@@ -1,7 +1,6 @@
 'use strict';
 
 // GLOBAL
-const execa = require('execa');
 const path = require('path');
 
 // LOCAL
@@ -14,7 +13,7 @@ const innerCommon = require('./common');
 const innerCompositeCore = require('./composite-core');
 
 // FETCH ARGS
-const { dryRun, skipInstall } = tools.getArgs();
+const { remotesImport } = tools.getArgs();
 
 
 
@@ -38,6 +37,101 @@ const getDeps = module.exports.getDeps = (prj, envTarget, compositeType) => {
     })
 }
 
+
+
+
+const getLocalProjectDeps = (prj, snapshotsMetadata) => {
+  tools.logInfo(`Getting deps for ${prj.name}`);
+
+  // check dependencies file - default
+  const prjJsonFile = path.join(process.cwd(), prj.folder, 'dependencies-base.json');
+  const prjDeps = tools.getJsonFileContent(prjJsonFile) || {};
+
+  // check dependencies composite file - default
+  const prjCompJsonFile = path.join(process.cwd(), prj.folder, 'dependencies-composite.json');
+
+  const depsJson = tools.getJsonFileContent(prjCompJsonFile);
+  let prjCompDeps;
+  if (depsJson.dependencies) {
+    prjCompDeps = depsJson.dependencies || {};
+  } else {
+    prjCompDeps = depsJson || {}
+  }
+
+  return { ...prjDeps, ...prjCompDeps };
+}
+
+
+module.exports.getLocalProjectsDeps = () => {
+  tools.logTitle('Getting project dependencies');
+
+  const projects = configUtils.projects.getProjects();
+  let deps = {};
+
+  projects.forEach(p => {
+    if (p) {
+      const prjDeps = getLocalProjectDeps(p);
+      deps = { ...deps, ...prjDeps };
+    }
+  })
+
+  return deps;
+}
+
+
+const getLocalProjectFixedDeps = (prj) => {
+  tools.logTitle('Getting project fixed dependencies - not part of the composite');
+
+  return Promise.resolve()
+    .then(() => {
+      return metadataUtils.package.getPackagesDeps('packages');
+    })
+
+    // extracting the fixed deps versions from metadata
+    .then((pkgDeps) => {
+      let deps = {};
+
+      if (prj.fixedDependencies) {
+        tools.logInfo('Project fixed dependencies found...processing');
+        console.log(prj.fixedDependencies);
+
+        prj.fixedDependencies.forEach((dep) => {
+          const newDep = { [dep]: pkgDeps[dep] };
+          deps = { ...deps, ...newDep }
+        })
+      }
+
+      tools.logInfo('Project fixed dependencies remapped : ');
+      console.log(deps);
+
+      return deps;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+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};
+    return deps;
+  })
+
+  await Promise.all(promises);
+  return deps;
+}
+
+
+
+
+
+
 module.exports.installDeps = (prj, envTarget, compositeType) => {
   let finalDeps, compositeDeps;
 
@@ -86,3 +180,109 @@ module.exports.installDepsStandalone = (prj) => {
       throw e;
     })
 }
+
+
+
+const getLocalProjectRemoteDeps = module.exports.getLocalProjectRemoteDeps = (prj) => {
+
+  if (prj.initRemoteDependencies && remotesImport) {
+
+    tools.logTitle('Importing remotes deps');
+
+    return Promise.resolve()
+      .then(() => {
+        return metadataUtils.package.getPackagesDeps('packages');
+      })
+
+      .then((snapshotsMetadata) => {
+        let remoteDeps = {};
+
+        const euiVersion = configUtils.projects.getProjectEuiVersion(prj).split('.')[0];
+        const remotes = configUtils.packages.getCsdrRemotePackages(euiVersion, prj.hostName);
+
+        remotes
+          .map((p) => {
+            return { npmgPkg: p.npmPkg, version: snapshotsMetadata[p.npmPkg] }
+          })
+          .forEach((r) => {
+            if (!r.version) {
+              tools.logInfo(`${r.npmgPkg} => no version found, probably the remote hasn't been released yet...skipping`)
+            } else {
+              remoteDeps[r.npmgPkg] = r.version;
+            }
+          })
+
+        tools.logInfo('Remotes found :');
+        console.log(remoteDeps);
+
+        return remoteDeps;
+      })
+  }
+}
+
+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};
+    return deps;
+  })
+
+  await Promise.all(promises);
+  return deps;
+}
+
+
+
+module.exports.importLocalProjectRemotes = (prj, remoteDeps) => {
+  if (prj.initRemoteDependencies) {
+    tools.logInfo(`Import remotes for project : ${prj.name}`);
+
+    remoteDeps = Object.keys(remoteDeps);
+
+    if (remoteDeps.length === 0) {
+      tools.logWarning('Remotes dependencies not found for project...skipping');
+
+    } else {
+      tools.logInfo(`Initializing ${remoteDeps.length} remotes`);
+
+      remoteDeps.forEach((remoteNpmPkg) => {
+        tools.logInfo(`Checking import for : ${remoteNpmPkg}`);
+
+        // check if package has been installed locally
+        if (configUtils.packages.isLocalPackage(remoteNpmPkg)) {
+          tools.logInfo('remote is installed locally...skipping import');
+
+        } else {
+          const pkg = configUtils.packages.getPackageByNpmPkg(remoteNpmPkg, true);
+          const projectElementsPath = path.join(process.cwd(), prj.folder, 'src', 'assets', 'elements', pkg.name, 'bundles');
+
+          const npmPkgScope = remoteNpmPkg.substr(0, remoteNpmPkg.indexOf('/'));
+          const npmPkgName = remoteNpmPkg.substr(remoteNpmPkg.indexOf('/') + 1);
+          const remoteNmPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, 'bundles');
+
+          tools.logInfo(`${remoteNpmPkg} - injecting in ${projectElementsPath}`);
+          tools.copydir(remoteNmPath, projectElementsPath);
+        }
+      });
+    }
+  }
+}
+
+
+module.exports.importLocalProjectsRemotes = (deps) => {
+  const projects = configUtils.projects.getProjects();
+
+  tools.logTitle('Importing local projects remotes');
+
+  if (remotesImport) {
+    projects.forEach(p => {
+      if (p) {
+        this.importLocalProjectRemotes(p, deps);
+      }
+    })
+  }
+}
+