In the terminal type the following command to install Node. $ brew install node If everything installed successfully then you can type in the following command in the terminal to check the Node and NPM version. $ node -v v7.7.2. Node@14: 329: Installs on Request (30 days) node@14: 254: Build Errors (30 days) node@14: 18: Installs (90 days) node@14: 841: Installs on Request (90 days) node@14: 727: Installs (365 days) node@14: 1,533: Installs on Request (365 days) node@14: 1,385.
Node version manager is a script to manage multiple active node.js versions. And I usually install most applications using homebrew.
NOTE:install NVM with Homebrew is not officially supported.
So these are the steps to install NVM with Homebrew:
- Install NVM with Homebrew
Install NVM is very easy just with this command:
- First setup
The first thing we need to do is create a folder for the current user.nvm
where the files will reside.
- Install a node version
There are different node versions that you can install; if you want to install the last version is very simple just using the command:
But I work with the long-term support version and the command to install the last LTS version is the command below:
- Start using the node version installed with NVM
After you installed the node version that you are looking it will be active after this command:
The previous command is also useful if you want to change from different Node.js versions.
To check if everything is working as expected the command bellow print the node version:
Finally, we want to execute NVM in every shell session, so let's create two user environment variables NVM_DIR
and NVM_HOMEBREW
.
Generally, environment variables are going in the file ~/.bash_profile
if you are using BASH or in the ~/.zshenv
file if you are using ZSH, but it will work also if you want to put the code below in the file ~/.bashrc
for BASH or ~/.zshrc
for ZSH.
You can use '$(brew --prefix nvm)/nvm.sh'
instead of '/usr/local/opt/nvm/nvm.sh'
but it will be slower.
The NODE_PATH
variable can also be useful for some applications, for example, VScode, this is the code you need to put after the previous variables.
This document explains how to successfully use Node and npm in a Node module based Homebrew formula.
Running npm install
Homebrew provides two helper methods in a Language::Node
module: std_npm_install_args
and local_npm_install_args
. They both set up the correct environment for npm and return arguments for npm install
for their specific use cases. Your formula should use these instead of invoking npm install
explicitly. The syntax for a standard Node module installation is:
where libexec
is the destination prefix (usually the libexec
variable).
Download URL
If the Node module is also available on the npm registry, we prefer npm hosted release tarballs over GitHub (or elsewhere) hosted source tarballs. The advantages of these tarballs are that they don’t include the files from the .npmignore
(such as tests) resulting in a smaller download size and that any possible transpilation step is already done (e.g. no need to compile CoffeeScript files as a build step).
The npm registry URLs usually have the format of:
Alternatively you could curl
the JSON at https://registry.npmjs.org/<name>
and look for the value of versions[<version>].dist.tarball
for the correct tarball URL.
Dependencies
Node modules which are compatible with the latest Node version should declare a dependency on the node
formula.
If your formula requires being executed with an older Node version you should use one of the versioned node formulae (e.g. node@12
).
Special requirements for native addons
If your Node module is a native addon or has a native addon somewhere in its dependency tree you have to declare an additional dependency. Since the compilation of the native addon results in an invocation of node-gyp
we need an additional build time dependency on 'python'
(because GYP depends on Python).
Also note that such a formula would only be compatible with the same Node major version it originally was compiled with. This means that we need to revision every formula with a Node native addon with every major version bump of the node
formula. To make sure we don’t overlook your formula on a Node major version bump, write a meaningful test which would fail in such a case (invoked with an ABI-incompatible Node version).
Installation
Node modules should be installed to libexec
. This prevents the Node modules from contaminating the global node_modules
, which is important so that npm doesn’t try to manage Homebrew-installed Node modules.
In the following we distinguish between two types of Node modules installed using formulae:
- formulae for standard Node modules compatible with npm’s global module format which should use
std_npm_install_args
(likeazure-cli
orwebpack
) - formulae where the
npm install
call is not the only required install step (e.g. need to also compile non-JavaScript sources) which have to uselocal_npm_install_args
(likeelixirscript
orgrunt-cli
)
What both methods have in common is that they are setting the correct environment for using npm inside Homebrew and are returning the arguments for invoking npm install
for their specific use cases. This includes fixing an important edge case with the npm cache (caused by Homebrew’s redirection of HOME
during the build and test process) by using our own custom npm_cache
inside HOMEBREW_CACHE
, which would otherwise result in very long build times and high disk space usage.
To use them you have to require the Node language module at the beginning of your formula file with:
Installing global style modules with std_npm_install_args
to libexec
In your formula’s install
method, simply cd
to the top level of your Node module if necessary and then use system
to invoke npm install
with Language::Node.std_npm_install_args
like:
This will install your Node module in npm’s global module style with a custom prefix to libexec
. All your modules’ executables will be automatically resolved by npm into libexec/bin
for you, which is not symlinked into Homebrew’s prefix. We need to make sure these are installed. To do this we need to symlink all executables to bin
with:
Installing module dependencies locally with local_npm_install_args
Brew Node Js
In your formula’s install
method, do any installation steps which need to be done before the npm install
step and then cd
to the top level of the included Node module. Then, use system
with Language::Node.local_npm_install_args
to invoke npm install
like:
This will install all of your Node modules dependencies to your local build path. You can now continue with your build steps and take care of the installation into the Homebrew prefix
on your own, following the general Homebrew formula instructions.
Example
Installing a standard Node module based formula would look like this:
Tooling
Brew Node 14
You can use homebrew-npm-noob to automatically generate a formula like the example above for an npm package.