Release 0.5.0

Author: dannote

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.5.0
+
+- Add `NPM.install/2` for script context — works like `Mix.install/2`, installs to a content-addressed cache directory without requiring a Mix project
+- Add `NPM.installed?/0`, `NPM.install_dir!/0`, `NPM.node_modules_dir!/0` helpers
+- `mix npm.install` now accepts multiple packages: `mix npm.install lodash react vue`
+- Fix infinite loop when a package lists itself as a dependency (e.g. `sqlite-napi`)
+
 ## 0.4.6
 
 - Add packument disk cache (`~/.npm_ex/packuments/`) with 1h TTL — avoids refetching registry metadata on repeat installs

lib/mix/tasks/npm.install.ex

@@ -11,6 +11,7 @@ defmodule Mix.Tasks.Npm.Install do
       mix npm.install --frozen                # Fail if lockfile is stale (CI)
       mix npm.install --production            # Skip devDependencies
       mix npm.install eslint --save-dev       # Add to devDependencies
+      mix npm.install lodash react vue        # Add multiple packages
 
   Resolves all dependencies using the PubGrub solver, writes `npm.lock`,
   and links packages into `node_modules/`.
@@ -25,8 +26,7 @@ defmodule Mix.Tasks.Npm.Install do
 
     case positional do
       [] -> NPM.install(opts)
-      [spec] -> install_spec(spec, opts)
-      _ -> Mix.shell().error("Usage: mix npm.install [package[@range]] [--frozen] [--save-dev]")
+      specs -> Enum.each(specs, &install_spec(&1, opts))
     end
   end
 

lib/npm.ex

@@ -22,7 +22,49 @@ defmodule NPM do
   @node_modules "node_modules"
 
   @doc """
-  Install all dependencies from `package.json`.
+  Install npm packages in a script context, without a Mix project.
+
+  Works like `Mix.install/2` — installs to a content-addressed cache directory,
+  is idempotent, and can only be called once per VM (raises on different deps).
+
+      NPM.install(%{"tailwindcss" => "^4.2.2"})
+
+  After installation, use `NPM.install_dir!/0` and `NPM.node_modules_dir!/0`
+  to locate the installed packages.
+
+  ## Options
+
+    * `:force` — reinstall even if cached (default: `false`)
+  """
+  @spec install(map(), keyword()) :: :ok
+  def install(deps, opts) when is_map(deps) do
+    NPM.ScriptInstall.install(deps, opts)
+  end
+
+  @doc """
+  Returns whether `NPM.install/2` has been called in this VM.
+  """
+  @spec installed? :: boolean()
+  defdelegate installed?, to: NPM.ScriptInstall
+
+  @doc """
+  Returns the root directory of the current `NPM.install/2` installation.
+
+  Raises if `NPM.install/2` has not been called.
+  """
+  @spec install_dir! :: String.t()
+  defdelegate install_dir!, to: NPM.ScriptInstall
+
+  @doc """
+  Returns the `node_modules` path of the current `NPM.install/2` installation.
+
+  Raises if `NPM.install/2` has not been called.
+  """
+  @spec node_modules_dir! :: String.t()
+  defdelegate node_modules_dir!, to: NPM.ScriptInstall
+
+  @doc """
+  Install all dependencies from `package.json` (project context).
 
   ## Options
 
@@ -31,7 +73,7 @@ defmodule NPM do
     * `:production` - when `true`, skips `devDependencies`.
   """
   @spec install(keyword()) :: :ok | {:error, term()}
-  def install(opts \\ []) do
+  def install(opts \\ []) when is_list(opts) do
     case NPM.PackageJSON.read_all() do
       {:ok, %{dependencies: deps, dev_dependencies: dev_deps, optional_dependencies: opt_deps}} ->
         all_deps =

lib/npm/resolver.ex

@@ -229,7 +229,7 @@ defmodule NPM.Resolver do
   @impl true
   def dependencies(_repo, package, version) do
     case get_cached_packument(package) do
-      {:ok, packument} -> deps_for_version(packument, to_string(version))
+      {:ok, packument} -> deps_for_version(package, packument, to_string(version))
       {:error, _} -> :error
     end
   end
@@ -262,7 +262,7 @@ defmodule NPM.Resolver do
     |> Enum.sort(Version)
   end
 
-  defp deps_for_version(packument, version_str) do
+  defp deps_for_version(package, packument, version_str) do
     excluded = get_excluded()
 
     case Map.get(packument.versions, version_str) do
@@ -274,17 +274,18 @@ defmodule NPM.Resolver do
 
         deps =
           info
-          |> solver_dependencies(excluded, overrides)
+          |> solver_dependencies(package, excluded, overrides)
 
         {:ok, deps}
     end
   end
 
-  defp solver_dependencies(info, excluded, overrides) do
+  defp solver_dependencies(info, self_name, excluded, overrides) do
     optional_dependency_names = Map.keys(info.optional_dependencies)
 
     required =
       info.dependencies
+      |> Enum.reject(fn {name, _} -> name == self_name end)
       |> Enum.reject(fn {name, _} -> name in optional_dependency_names end)
       |> Enum.reject(fn {name, _} -> MapSet.member?(excluded, name) end)
       |> Enum.map(fn {name, range} -> {name, Map.get(overrides, name, range), false} end)

lib/npm/script_install.ex

@@ -0,0 +1,128 @@
+defmodule NPM.ScriptInstall do
+  @moduledoc false
+
+  @state_key :npm_script_installed
+
+  @spec install(map(), keyword()) :: :ok
+  def install(deps, opts) when is_map(deps) do
+    Application.ensure_all_started(:req)
+
+    unless Keyword.get(opts, :__skip_project_check__, false) do
+      if Mix.Project.get() do
+        Mix.raise("NPM.install/2 cannot be used inside a Mix project. Use mix npm.install instead.")
+      end
+    end
+
+    id = cache_id(deps)
+    force? = Keyword.get(opts, :force, false)
+
+    case :persistent_term.get(@state_key, nil) do
+      nil ->
+        do_install(deps, id, force?)
+
+      {^id, _dir} when not force? ->
+        :ok
+
+      {^id, _dir} ->
+        do_install(deps, id, true)
+
+      _ ->
+        Mix.raise("NPM.install/2 can only be called with the same dependencies in the given VM")
+    end
+  end
+
+  defp do_install(deps, id, force?) do
+    dir = install_dir(id)
+
+    if force?, do: File.rm_rf!(dir)
+
+    nm_dir = Path.join(dir, "node_modules")
+    lockfile_path = Path.join(dir, "npm.lock")
+
+    if not force? and File.exists?(lockfile_path) and node_modules_intact?(lockfile_path, nm_dir) do
+      :persistent_term.put(@state_key, {id, dir})
+      :ok
+    else
+      File.mkdir_p!(dir)
+      resolve_and_link(deps, dir, nm_dir, lockfile_path)
+      :persistent_term.put(@state_key, {id, dir})
+      :ok
+    end
+  end
+
+  defp resolve_and_link(deps, _dir, nm_dir, lockfile_path) do
+    NPM.Resolver.clear_cache()
+
+    case NPM.Resolver.resolve(deps) do
+      {:ok, resolved} ->
+        {_nested, flat} = Map.pop(resolved, :nested, %{})
+        lockfile = build_lockfile(flat)
+        NPM.Lockfile.write(lockfile, lockfile_path)
+        NPM.Linker.link(lockfile, nm_dir)
+
+      {:error, message} ->
+        Mix.raise("NPM.install/2 resolution failed:\n#{message}")
+    end
+  end
+
+  defp build_lockfile(resolved) do
+    for {name, version_str} <- resolved, into: %{} do
+      {:ok, packument} = NPM.Registry.get_packument(name)
+      info = Map.fetch!(packument.versions, version_str)
+
+      {name,
+       %{
+         version: version_str,
+         integrity: info.dist.integrity,
+         tarball: info.dist.tarball,
+         dependencies: info.dependencies,
+         optional_dependencies: info.optional_dependencies
+       }}
+    end
+  end
+
+  defp node_modules_intact?(lockfile_path, nm_dir) do
+    case NPM.Lockfile.read(lockfile_path) do
+      {:ok, lockfile} when lockfile != %{} ->
+        Enum.all?(lockfile, fn {name, _} ->
+          File.exists?(Path.join([nm_dir, name, "package.json"]))
+        end)
+
+      _ ->
+        false
+    end
+  end
+
+  defp cache_id(deps) do
+    deps
+    |> :erlang.term_to_binary()
+    |> :erlang.md5()
+    |> Base.encode16(case: :lower)
+  end
+
+  defp install_dir(id) do
+    root =
+      System.get_env("NPM_INSTALL_DIR") ||
+        Path.join(NPM.Cache.dir(), "installs")
+
+    Path.join(root, id)
+  end
+
+  @spec installed? :: boolean()
+  def installed? do
+    :persistent_term.get(@state_key, nil) != nil
+  end
+
+  @spec install_dir! :: String.t()
+  def install_dir! do
+    case :persistent_term.get(@state_key, nil) do
+      {_id, dir} -> dir
+      nil -> Mix.raise("NPM.install/2 has not been called")
+    end
+  end
+
+  @spec node_modules_dir! :: String.t()
+  def node_modules_dir! do
+    Path.join(install_dir!(), "node_modules")
+  end
+end

mix.exs

@@ -1,7 +1,7 @@
 defmodule NPM.MixProject do
   use Mix.Project
 
-  @version "0.4.6"
+  @version "0.5.0"
   @source_url "https://github.com/elixir-volt/npm_ex"
 
   def project do

test/npm/script_install_test.exs

@@ -0,0 +1,47 @@
+defmodule NPM.ScriptInstallTest do
+  use ExUnit.Case, async: false
+
+  @test_opts [__skip_project_check__: true]
+
+  setup do
+    :persistent_term.erase(:npm_script_installed)
+    :ok
+  end
+
+  test "installs packages to content-addressed cache dir" do
+    deps = %{"is-number" => "^7.0.0"}
+    assert :ok = NPM.ScriptInstall.install(deps, @test_opts)
+    assert NPM.ScriptInstall.installed?()
+
+    nm = NPM.ScriptInstall.node_modules_dir!()
+    assert File.exists?(Path.join(nm, "is-number/package.json"))
+  end
+
+  test "second call with same deps is a noop" do
+    deps = %{"is-number" => "^7.0.0"}
+    assert :ok = NPM.ScriptInstall.install(deps, @test_opts)
+    assert :ok = NPM.ScriptInstall.install(deps, @test_opts)
+  end
+
+  test "second call with different deps raises" do
+    deps1 = %{"is-number" => "^7.0.0"}
+    deps2 = %{"is-odd" => "^3.0.0"}
+    assert :ok = NPM.ScriptInstall.install(deps1, @test_opts)
+
+    assert_raise Mix.Error, ~r/same dependencies/, fn ->
+      NPM.ScriptInstall.install(deps2, @test_opts)
+    end
+  end
+
+  test "force reinstalls" do
+    deps = %{"is-number" => "^7.0.0"}
+    assert :ok = NPM.ScriptInstall.install(deps, @test_opts)
+    assert :ok = NPM.ScriptInstall.install(deps, [force: true] ++ @test_opts)
+  end
+
+  test "install_dir! raises when not installed" do
+    assert_raise Mix.Error, ~r/not been called/, fn ->
+      NPM.ScriptInstall.install_dir!()
+    end
+  end
+end