@eui/tools 6.1.0 → 6.1.2

package/scripts/csdr/install/common.js

@@ -10,20 +10,34 @@ const configUtils = require('../config/config-utils');
 const metadataUtils = require('../metadata/metadata-utils');
 
 // FETCH ARGS
-const { dryRun, skipInstall, registry, remotesImport, skipLocalPackagesDeps } = tools.getArgs();
+const { dryRun, skipInstall, registry, skipLocalPackagesDeps } = tools.getArgs();
 
 
+const getInstallRegistry = () => {
+  const NPM_REGISTRY_INSTALL = configUtils.global.getConfigOptions().NPM_REGISTRY_INSTALL;
+
+  // check if registry has been passed as argument
+  var installRegistry;
+  if (registry) {
+    installRegistry = registry;
+  } else {
+    installRegistry = NPM_REGISTRY_INSTALL;
+  }
+
+  return installRegistry;
+}
+
 
-const installDeps = (deps) => {
+module.exports.installDeps = (deps) => {
 
   return Promise.resolve()
-    // Install dependencies
-    .then(() => {
-      tools.logTitle('Package dependencies to install : ');
+  // Install dependencies
+  .then(() => {
+    tools.logTitle('Package dependencies to install : ');
 
-      const rootFolder = process.cwd();
-      const pkgJsonFile = path.resolve(rootFolder, 'package.json');
-      const pkgJson = require(pkgJsonFile);
+    const rootFolder = process.cwd();
+    const pkgJsonFile = path.resolve(rootFolder, 'package.json');
+    const pkgJson = require(pkgJsonFile);
 
       pkgJson.dependencies = deps;
 
@@ -43,21 +57,7 @@ const installDeps = (deps) => {
 }
 
 
-const getInstallRegistry = () => {
-  const NPM_REGISTRY_INSTALL = configUtils.global.getConfigOptions().NPM_REGISTRY_INSTALL;
-
-  // check if registry has been passed as argument
-  var installRegistry;
-  if (registry) {
-    installRegistry = registry;
-  } else {
-    installRegistry = NPM_REGISTRY_INSTALL;
-  }
-
-  return installRegistry;
-}
-
-const executeInstall = (cwdPath) => {
+const executeInstall = module.exports.executeInstall = (cwdPath) => {
   return Promise.resolve()
     .then(() => {
       const installRegistry = getInstallRegistry();
@@ -74,7 +74,7 @@ const executeInstall = (cwdPath) => {
 }
 
 
-const executeInstallPackage = (cwdPath, npmPkg) => {
+module.exports.executeInstallPackage = (cwdPath, npmPkg) => {
   return Promise.resolve()
   .then(() => {
     const installRegistry = getInstallRegistry();
@@ -91,7 +91,7 @@ const executeInstallPackage = (cwdPath, npmPkg) => {
 }
 
 
-const getRemappedDeps = (pkgDeps, pkgDefaultDeps, isMaster) => {
+module.exports.getRemappedDeps = (pkgDeps, pkgDefaultDeps, isMaster) => {
   tools.logTitle('Remapping major version carret declared dependencies');
 
   return Promise.resolve()
@@ -150,7 +150,7 @@ const getRemappedDeps = (pkgDeps, pkgDefaultDeps, isMaster) => {
 
 
 
-const getResolvedCarretDeps = (deps, isMaster) => {
+const getResolvedCarretDeps = module.exports.getResolvedCarretDeps = (deps, isMaster) => {
   tools.logTitle('Resolving carret versions for prev or next version packages');
 
   tools.logInfo('processing dependencies : ');
@@ -195,368 +195,3 @@ const getResolvedCarretDeps = (deps, isMaster) => {
     })
 }
 
-
-
-
-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 = () => {
-  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 = () => {
-  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 = () => {
-  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;
-}
-
-
-const getLocalPackagesCompositeDepsRemapped = () => {
-  return Promise.resolve()
-    .then(() => {
-      return metadataUtils.package.getPackagesDeps('packages');
-    })
-
-    .then((depsMetadata) => {
-      const compositeDeps = getLocalPackagesCompositeDeps();
-
-      return getRemappedDeps(depsMetadata, compositeDeps, false);
-    })
-
-    .then((remappedDeps) => {
-      tools.logInfo('Remapped deps : ');
-
-      console.log(remappedDeps);
-
-      return remappedDeps;
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-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 || {}
-  }
-
-  let remoteDeps = {};
-  if (prj.initRemoteDependencies && remotesImport && snapshotsMetadata) {
-
-    tools.logInfo('Importing remotes deps... this might take a while');
-
-    const remotes = configUtils.packages.getCsdrRemotePackages()
-      .filter((p) => {
-        return p.active === true
-      })
-      .map((p) => {
-        return { npmgPkg: p.npmPkg, version: snapshotsMetadata[p.npmPkg] }
-      })
-      .filter((dep) => {
-        return dep.version !== undefined
-      })
-
-    remotes.forEach((r) => {
-      remoteDeps[r.npmgPkg] = r.version;
-    });
-  }
-
-  return { ...prjDeps, ...prjCompDeps, ...remoteDeps };
-}
-
-
-const getLocalProjectsDeps = (snapshotsMetadata) => {
-  tools.logTitle('Getting project dependencies');
-
-  const projects = configUtils.projects.getProjects();
-  let deps = {};
-
-  projects.forEach(p => {
-    if (p) {
-      const prjDeps = getLocalProjectDeps(p, snapshotsMetadata);
-      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;
-    })
-}
-
-
-const 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;
-}
-
-
-const importLocalProjectRemotes = (prj, deps) => {
-  if (prj.initRemoteDependencies) {
-    tools.logInfo(`Import remotes for project : ${prj.name}`);
-
-    const remoteDeps = Object.keys(deps).filter((dep) => {
-      return dep.indexOf('remote-el') !== -1;
-    })
-
-    if (remoteDeps.length === 0) {
-      tools.logWarning('Remotes not found...skipping');
-
-    } else {
-      tools.logInfo(`Initializing ${remoteDeps.length} remotes`);
-
-      remoteDeps.forEach((remoteNpmPkg) => {
-        tools.logInfo(`Checking import for : ${remoteNpmPkg}`);
-
-        // check if package has been installed locally
-        const localPackage = configUtils.packages.getPackages().filter((p) => {
-          return p.npmPkg === remoteNpmPkg
-        })[0];
-
-        if (localPackage) {
-          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);
-        }
-
-      });
-    }
-  }
-}
-
-
-const importLocalProjectsRemotes = (deps) => {
-  const projects = configUtils.projects.getProjects();
-
-  tools.logTitle('Importing local projects remotes');
-
-  if (remotesImport) {
-    projects.forEach(p => {
-      if (p) {
-        importLocalProjectRemotes(p, deps);
-      }
-    })
-  }
-}
-
-
-
-module.exports = {
-  installDeps,
-  executeInstall,
-  executeInstallPackage,
-  getRemappedDeps,
-  getLocalPackageDeps,
-  getLocalPackagesDeps,
-  getLocalPackageCompositeDeps,
-  getLocalPackagesCompositeDeps,
-  getLocalPackagesCompositeDepsRemapped,
-  getLocalPackageBaseDeps,
-  getLocalPackagesBaseDeps,
-  getLocalProjectDeps,
-  getLocalProjectsDeps,
-  getLocalProjectFixedDeps,
-  getLocalProjectsFixedDeps,
-  importLocalProjectRemotes,
-  importLocalProjectsRemotes
-}

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,72 +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');
 
-// FETCH ARGS
-const { dryRun, skipInstall } = tools.getArgs();
+module.exports.installPackage = (pkgName) => {
 
+  const pkg = configUtils.packages.getPackage(pkgName, false, true);
 
+  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;
 
-  // specific if coming from init script and pkgOnly is provided, we only install the remote deps
-  if (pkg && typeof(pkg) === 'string') {
-    pkg = configUtils.packages.getPackage(pkg);
-  }
+
+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');
@@ -89,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);
     })
@@ -105,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(() => {