@eui/tools 6.1.0 → 6.1.1

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;
 
@@ -87,13 +181,108 @@ module.exports.installDepsStandalone = (prj) => {
     })
 }
 
-module.exports.installPackage = (prj, npmPkg) => {
-  return Promise.resolve()
-    .then(() => {
-      return innerCommon.executeInstallPackage(process.cwd(), npmPkg);
-    })
 
-    .catch((e) => {
-      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);
+      }
     })
+  }
 }
+

package/scripts/csdr/release/package/ui.js

@@ -8,7 +8,6 @@ const glob = require('glob');
 const installUtils = require('../../install/install-utils');
 const configUtils = require('../../config/config-utils');
 const auditUtils = require('../../audit/audit-utils');
-const notificationUtils = require('../../../utils/notification/notification-utils');
 const tools = require('../../../utils/tools');
 
 
@@ -26,16 +25,19 @@ module.exports.install = (pkg, isMaster) => {
     return installUtils.buildPackage.installPackage(prj, pkg, isMaster);
   })
 
-
   // CHECK INTERNAL DEPENDENCIES
   .then(() => {
-    return checkDeps(pkg);
+    return auditUtils.deps.audit(pkg);
   })
 
+  // CHECK STYLES USAGE
+  .then(() => {
+    return auditUtils.styles.audit(pkg);
+  })
 
   // AUDIT DEPENDENCIES
   .then(() => {
-    return auditUtils.audit(pkg);
+    return auditUtils.yarn.audit(pkg);
   })
 
 
@@ -63,84 +65,3 @@ module.exports.installOnly = (pkg) => {
     throw e;
   })
 }
-
-
-
-const checkDeps = (pkg) => {
-  tools.logTitle('Checking package internal dependencies');
-
-  return Promise.resolve()
-   .then(() => {
-     var depsFound = [];
-     var files = glob.sync('**/*.ts', { cwd: pkg.paths.pkgLibFolder, nodir: true, follow: true, dot: true });
-     files.forEach(file => {
-       const filePath = path.join(pkg.paths.pkgLibFolder, file);
-       const fileContent = tools.getFileContent(filePath);
-       var regex = /@cc\/|@mywp\/|@opsys\/|@sfc\//gi, result, indices = [];
-       while ( (result = regex.exec(fileContent)) ) {
-           indices.push(result.index);
-       }
-       if (indices.length !== 0) {
-         // tools.logInfo(`Number of occurences found : ${indices.length}`);
-         indices.forEach((i) => {
-           const endPos = fileContent.substr(i, 40).indexOf("'");
-           const dep = fileContent.substr(i, endPos);
-           if (endPos > -1) {
-             // tools.logInfo(`dep found on : ${dep}`);
-             depsFound.push(dep);
-
-           } else {
-             tools.logInfo(`Potential wrong import detected on file : ${file}`);
-             const subContent = fileContent.substr(i, 40);
-             const detectMultiSlashes = subContent.match(/\//g);
-             if (detectMultiSlashes.length > 0) {
-               tools.logError('Multislashes on import : ');
-               console.log(subContent);
-             }
-           }
-         })
-       }
-     });
-     depsFound = tools.removeArrayDuplicates(depsFound);
-     tools.logWarning(`Dependencies found : ${depsFound.length}`);
-     console.log(depsFound);
-
-     return depsFound;
-   })
-
-   .then((depsFound) => {
-     var depsLevel;
-
-     switch(true) {
-         case (depsFound.length === 1):
-           depsLevel = 'LOW (1)';
-           break;
-         case (depsFound.length > 1 && depsFound.length <= 3):
-           depsLevel = 'MEDIUM (between 1 and 3)';
-           break;
-         case (depsFound.length > 3 && depsFound.length <= 5):
-           depsLevel = 'HIGH (between 3 and 5)';
-           break;
-         case (depsFound.length > 5):
-           depsLevel = 'VERY HIGH (>5)';
-           break;
-         default:
-           depsLevel = 'NONE';
-     }
-
-     var message = `Internal dependencies detected : ${depsFound.length} - deps level: ${depsLevel}\n`;
-     message += depsFound.join('\n');
-
-
-     return notificationUtils.package.sendPackageMessage({
-      package: pkg,
-      text: message
-     });
-   })
-
-   .catch((e) => {
-     console.log(e);
-   })
-
- }
-

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

@@ -36,31 +36,31 @@ module.exports.sync = () => {
     return configUtils.sync.run();
   })
   .then(() => {
-    return initUtils.importScripts();
+    return initUtils.packages.importPackages({reset: true});
   })
   .then(() => {
-    return initUtils.importPackages({reset: true});
+    return initUtils.projects.importScripts();
   })
   .then(() => {
-    return initUtils.importExtraTsConfig();
+    return initUtils.projects.importExtraTsConfig();
   })
   .then(() => {
-    return initUtils.importExternalFeatures();
+    return initUtils.projects.importExternalFeatures();
   })
   .then(() => {
-    return initUtils.importExternalSources();
+    return initUtils.projects.importExternalSources();
   })
   .then(() => {
-    return initUtils.importExternalMock();
+    return initUtils.projects.importExternalMock();
   })
   .then(() => {
     return initUtils.meta.init();
   })
   .then(() => {
-    return initUtils.processLocalEuiVersions();
+    return initUtils.global.processLocalEuiVersions();
   })
   .then(() => {
-    return initUtils.processResolutionsForNodeVersion();
+    return initUtils.global.processResolutionsForNodeVersion();
   })
   .catch((e) => {
     throw e;