如何使用NPM处理Node.js中的本地包依赖关系

Question

How should we deal with local packages that are a dependency in other local packages?

For simplicities sake, say we have the follow packages

• api - express application
• people - a package to deal with people
• data-access - a package that deals with data access

And then the dependencies are

• api depends on people
• people depends on data-access

Currently we have these dependencies setup as file dependencies.

Ie api package.json would have

"dependencies": {
  "people": "file:../people"
}

Trouble with this is that we're finding it a PITA when we make updates to one package and want those changes in the other packages that depend on it.

The options we have thought of are:

• npm install - but this won't overwrite previously installed packages if changes are made, so we have to delete the old one from the node_modules directory and re-run npm install... which can be niggly if the package dependency is deep.

• npm link - we're not sold on the idea because it doesn't survive version control... Just thinking about it now, maybe we have some kind of local build script that would run the npm link commands for us... this way it could survive version control. Would that be a grunt job?

• grunt - we haven't dived too deep into this one yet, but it feels like a good direction. A little bit of googling we came accross this: https://github.com/ahutchings/grunt-install-dependencies

So, what option would work best for our situation?
Are there other options that we haven't thought of yet?

Ps. we're a .NET shop doing a PoC in node, so assume we know nothing!

Pps. if you strongly believe we're setting up our project incorrectly and we shouldn't have smaller individual packages, let me know in the comments with a link to some reading on the subject.

Answer 1

So, I agree that going with 'many small packages' is usually a good idea. Check out 12factor.net if you haven't already.

That said, in specific answer to your question I'd say your best bet is to consider mainly how you want to maintain them.

If the 'subcomponents' are all just parts of your app (as, for example, data-access implies), then I'd keep them in the same folder structure, not map them in package.json at all, and just require them where you need them. In this case, everything versions together and is part of the same git repository.

If you really want to or need to keep them all in separate git repositories, then you can do npm link, but to be honest I've found it more useful to just use the URL syntax in package.json:

dependencies: {
  "people" : "git://path.to.git:repo@version.number"
}

Then, when you want to explicitly update one of your dependencies, you just have to bump the version number in your package.json and run npm install again.