Run npm install on all library automatically

[jogelin]

• I'm submitting a ...
  [ ] bug report
  [X] feature request
  [ ] question about the decisions made in the repository

• Do you want to request a feature or report a bug?
  When a library depends on a third part library which is not shared, we should be able to execute npm install automatically.

• What is the current behavior?
  The command npm run lib:build doesn't compile because it doesn't find the third part library specified in the code.

• Reproduce
  Simply having an external dependency (not a peer or a dev dependency) in the package.json of the library.

• What is the expected behavior?
  When we do the main npm install or when we do npm run lib:sync or other, execute the npm install for each library

• What is the motivation / use case for changing the behavior?
  On a CI environment, I need to manually run npm install on each library

[shlomiassaf]

This requires a script that run's npm install on each library.

I didn't dive deep into this scenario but it will probably require some thinking.

There are 2 approaches:

• Put everything in the node_modules of root folder
• Put package specific deps on a local node_modules folder in the package's root (your suggestion)

Now, the first approach is the simplest to go with but it does not work when 2 (or more) packages want the same 3rd party library but in a different versions... A problem.

---

The 2nd approach ensure consistency but might cause serious module resolution issues.

There are a-lot of processes involved here, Webpack, TypeScript, awesome-typescript-loader, Jest, Angular compiler, ts-wrapped, tsickle and probably more...

They all need to know how to resolve modules and how to map them...

It's fairly easy to tame Webpack, TypeScript can also work but with a bit more work and for the rest i'll just have to see

The complexity is enormous...

On a multi-packages repo, if the packages you build start referencing each other it becomes a nightmare... The compilation process runs once for a package but compiles everything so resolving these modules internally on the same TS process with same config is a big problem.

To workaround that i'll have to control the build workflow completely, this means building packages one by one, based on deps, and then inject their outputd.ts into the next lib that depends on them so TS will not have to build them. Wow, that's a lot of work!

---

I don't know how others handle it, lerna or something... worth checking,.

To conclude, I think the best approach for now is the first one I mentioned.
Yes, packages require to have their dependencies aligned but this is a smart thing...
Anyway, you won't be able to run the demo app when there are 2 different versions of the same package... so it's also a must

[jogelin]

Yes, I know it's a nightmare :(

I know that lerna is managing all mappings with npm links....but after you need to unlink, etc...I had a lot of issue trying that.

For now, on my side, I just use a local node_modules for external library that I don't want to put in the root node_modules. For common dependencies and local dependencies, I put them in the peerDependencies section.

For the moment, I created a script that run npm install in each library:
exec.js

'use strict';

const fs = require('fs');
const exec = require('child_process').exec;

module.exports.exec = function execLibs(command, rootDir) {

  const rootPackageFile = `./package.json`;
  const rootPackageJson = JSON.parse(fs.readFileSync(rootPackageFile).toString());
  const libConfig = rootPackageJson.libConfig;
  const packages = libConfig.packages;

  Promise.all(packages.map(pkg => execLib(command, `${rootDir}/${libConfig.scope}/${pkg}`)))
    .then(
      values => {
        console.log(values);
      },
      reason => {
        console.error(reason);
        process.exit(1);
      }
    );
};

function execLib(command, path) {
  return execute(command.replace('${path}', path));
}

function execute(script) {
  return new Promise((resolve, reject) => {
    exec(script, (error, stdout, stderr) => {
      if (error) {
        reject(stderr);
      } else {
        resolve(stdout);
      }
    });
  });
}

install.js

'use strict';

const exec = require('./exec').exec;
exec('cd ${path} && yarn', 'src');

package.json

"lib:install": "node scripts/install.js"

I know the code is not clean but it works for the moment...