Release 0.4.5

Author: dannote

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.4.5
+
+- Switch default linker strategy from symlink to copy, fixing ESM module resolution for cached packages
+- Fix `NodeRunner` entrypoint resolution to follow bin symlinks correctly
+- Cache platform binding selection results, reducing resolve time from ~35s to ~1.5s for packages like `oxfmt`
+- Generalize platform binding family detection for both old-style (`@oxfmt/darwin-arm64`) and new-style (`@oxfmt/binding-darwin-arm64`) naming
+- Avoid grouping non-platform optional dependencies (e.g. `@babel/core`) as platform variants
+
 ## 0.4.4
 
 - Fix npm registry packument decoding for optional platform dependency inspection

lib/npm/linker.ex

@@ -301,9 +301,6 @@ defmodule NPM.Linker do
   end
 
   defp default_strategy do
-    case :os.type() do
-      {:unix, _} -> :symlink
-      _ -> :copy
-    end
+    :copy
   end
 end

lib/npm/node_runner.ex

@@ -3,13 +3,16 @@ defmodule NPM.NodeRunner do
 
   @spec run(String.t(), [String.t()], keyword()) :: {String.t(), non_neg_integer()}
   def run(entrypoint, args, opts \\ []) do
-    node_modules_dir = Keyword.get(opts, :node_modules_dir, "node_modules")
+    node_modules_dir = Path.expand(Keyword.get(opts, :node_modules_dir, "node_modules"))
     env = Keyword.get(opts, :env, []) ++ NPM.Exec.env(node_modules_dir)
+    entrypoint = resolve_entrypoint(Path.expand(entrypoint), node_modules_dir)
 
-    loader_path = write_loader(Path.expand(node_modules_dir), Path.expand(entrypoint))
+    loader_path = write_loader(node_modules_dir, entrypoint)
 
     try do
-      System.cmd("node", [loader_path | args],
+      node_args = ["--preserve-symlinks", "--preserve-symlinks-main", loader_path | args]
+
+      System.cmd("node", node_args,
         env: env,
         stderr_to_stdout: true,
         cd: Keyword.get(opts, :cd, File.cwd!())
@@ -19,16 +22,63 @@ defmodule NPM.NodeRunner do
     end
   end
 
+  defp resolve_entrypoint(entrypoint, node_modules_dir) do
+    bin_dir = Path.join(node_modules_dir, ".bin")
+
+    if String.starts_with?(entrypoint, bin_dir) do
+      command = Path.basename(entrypoint)
+
+      case find_package_entrypoint(command, node_modules_dir) do
+        {:ok, resolved} -> resolved
+        :error -> entrypoint
+      end
+    else
+      entrypoint
+    end
+  end
+
+  defp find_package_entrypoint(command, node_modules_dir) do
+    bin_path = Path.join([node_modules_dir, ".bin", command])
+    real_bin_path = resolve_symlink(bin_path)
+
+    with {:ok, content} <- File.read(real_bin_path),
+         [_, rel_path] <- Regex.run(~r{import\s+["'](\.\./[^"']+)["']}, content) do
+      {:ok, Path.expand(rel_path, Path.dirname(real_bin_path))}
+    else
+      _ ->
+        case NPM.Exec.which(command, node_modules_dir) do
+          {:ok, pkg_path} -> {:ok, Path.expand(pkg_path)}
+          _ -> :error
+        end
+    end
+  end
+
+  defp resolve_symlink(path, depth \\ 10)
+  defp resolve_symlink(path, 0), do: path
+
+  defp resolve_symlink(path, depth) do
+    case File.read_link(path) do
+      {:ok, target} ->
+        resolve_symlink(Path.expand(target, Path.dirname(path)), depth - 1)
+
+      {:error, _} ->
+        path
+    end
+  end
+
   defp write_loader(node_modules_dir, entrypoint) do
-    path = Path.join(System.tmp_dir!(), "npm-node-runner-#{System.unique_integer([:positive])}.mjs")
+    path = Path.join(Path.dirname(node_modules_dir), ".npm-node-runner-#{System.unique_integer([:positive])}.mjs")
 
     File.write!(path, """
     import { createRequire } from 'node:module'
-    const require = createRequire(import.meta.url)
-    globalThis.require = require
-    process.env.NODE_PATH = #{inspect(node_modules_dir)}
+    import { pathToFileURL } from 'node:url'
+
+    const nmDir = #{inspect(node_modules_dir)}
+    globalThis.require = createRequire(pathToFileURL(nmDir + '/').href)
+    process.env.NODE_PATH = nmDir
     require('node:module').Module._initPaths()
-    await import(#{inspect(entrypoint)})
+
+    await import(pathToFileURL(#{inspect(entrypoint)}).href)
     """)
 
     path

lib/npm/platform_optional.ex

@@ -2,10 +2,25 @@ defmodule NPM.PlatformOptional do
   @moduledoc false
 
   @spec select(map()) :: map()
+  def select(optional_dependencies) when map_size(optional_dependencies) == 0, do: %{}
+
   def select(optional_dependencies) when is_map(optional_dependencies) do
-    grouped = Enum.group_by(optional_dependencies, fn {name, _range} -> package_family(name) end)
+    cache_key = :erlang.phash2(optional_dependencies)
+
+    case Process.get({__MODULE__, cache_key}) do
+      nil ->
+        result = do_select(optional_dependencies)
+        Process.put({__MODULE__, cache_key}, result)
+        result
+
+      cached ->
+        cached
+    end
+  end
 
-    grouped
+  defp do_select(optional_dependencies) do
+    optional_dependencies
+    |> Enum.group_by(fn {name, _range} -> package_family(name) end)
     |> Enum.flat_map(fn {_family, deps} -> select_group(deps) end)
     |> Map.new()
   end
@@ -48,19 +63,33 @@ defmodule NPM.PlatformOptional do
     end
   end
 
+  @platform_tokens ~w(darwin linux win32 freebsd android openharmony arm64 x64 ia32 arm x86 ppc64 s390x riscv64 musl gnu msvc gnueabihf musleabihf)
+
   defp package_family(name) do
-    cond do
-      String.starts_with?(name, "@oxfmt/binding-") -> "@oxfmt/binding"
-      String.starts_with?(name, "@oxlint/binding-") -> "@oxlint/binding"
-      true -> name
+    if platform_binding?(name) do
+      case Regex.run(~r/^(@[^\/]+\/)/, name) do
+        [scope | _] -> scope
+        nil ->
+          case String.split(name, "-", parts: 2) do
+            [prefix, _] -> prefix
+            _ -> name
+          end
+      end
+    else
+      name
     end
   end
 
+  defp platform_binding?(name) do
+    lower = String.downcase(name)
+    Enum.count(@platform_tokens, &String.contains?(lower, &1)) >= 2
+  end
+
   @spec current_match(String.t()) :: boolean()
   def current_match(name) do
-    current_os = NPM.Platform.current_os()
-    current_cpu = NPM.Platform.current_cpu()
-    String.contains?(name, "-#{current_os}-") and String.ends_with?(name, "-#{current_cpu}") or
-      String.ends_with?(name, "-#{current_os}-#{current_cpu}")
+    os = NPM.Platform.current_os()
+    cpu = NPM.Platform.current_cpu()
+    lower = String.downcase(name)
+    String.contains?(lower, os) and String.contains?(lower, cpu)
   end
 end

mix.exs

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