Add Node 24 support and refactor version-to-archive mapping (#1373)

* Add Node 24 support and refactor version-to-archive mapping

Refactors Node version management to use a tuple array mapping versions to nix archive hashes, similar to the Swift and Go providers. This makes it easier to maintain and add new Node versions.

- Add Node 24 support with specific nix archive (23f9169c4ccce521379e602cc82ed873a1f1b52b)
- Remove Node 23 (was unreachable due to LTS filtering)
- Add Node 22-specific nix archive (e6f23dc08d3624daab7094b701aa3954923c6bbb)
- Update Bun nixpkgs archive to 31fb21469e34b6b5c7be77b9a35bae43d0c598e9
- Refactor AVAILABLE_NODE_VERSIONS from array to tuple array with archive hashes
- Replace if/else chain in get_nix_archive() with lookup function
- Add version_number_to_archive() helper function
- Add pnpm 10 support (lockfileVersion 9.0)
- Add node-24-pnpm-10 example

* lint fix

* Fix pnpm version detection to respect packageManager field

Both pnpm 9 and 10 use lockfileVersion '9.0', making them
indistinguishable by lockfile alone. This fix prioritizes the
packageManager field in package.json when determining which pnpm
version to use.

Changes:
- Parse packageManager field (e.g., "[email protected]") to extract version
- Map parsed version to appropriate nix package (pnpm-9_x, pnpm-10_x)
- Fall back to lockfile detection only when packageManager is absent
- Default lockfileVersion '9.0' to pnpm-9_x (when introduced)
- Add packageManager field to node-24-pnpm-10 example for pnpm 10
- Update test snapshots

This ensures pnpm 10 is only used when explicitly specified in the
packageManager field, fixing the node-pnpm-corepack example which
was incorrectly using pnpm-10_x instead of pnpm-9_x.

* Fix clippy and dead_code warnings

- Remove unused PackageJsonNx and PackageJsonNxTargets structs
- Simplify pnpm lockfile detection by removing redundant else-if branch

Author: coffee-cup

examples/node-24-pnpm-10/index.js

@@ -0,0 +1 @@
+console.log("Hello from Node");

examples/node-24-pnpm-10/node_modules/.pnpm-workspace-state.json

@@ -0,0 +1,12 @@
+{
+  "name": "node",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "engines": {
+    "node": "24.x"
+  },
+  "packageManager": "[email protected]"
+}

examples/node-24-pnpm-10/package.json

@@ -50,7 +50,7 @@ pub mod nixpacks;
 pub mod providers;
 
 /// Supplies all currently-defined providers to build plan generators and image builders.
-pub fn get_providers() -> &'static [&'static (dyn Provider)] {
+pub fn get_providers() -> &'static [&'static dyn Provider] {
     &[
         &CrystalProvider {},
         &CSharpProvider {},

examples/node-24-pnpm-10/pnpm-lock.yaml

@@ -26,7 +26,7 @@ pub struct GeneratePlanOptions {
 
 /// Holds plan options and providers for a build.
 pub struct NixpacksBuildPlanGenerator<'a> {
-    providers: &'a [&'a (dyn Provider)],
+    providers: &'a [&'a dyn Provider],
     config: GeneratePlanOptions,
 }
 
@@ -50,7 +50,7 @@ impl PlanGenerator for NixpacksBuildPlanGenerator<'_> {
 
 impl NixpacksBuildPlanGenerator<'_> {
     pub fn new<'a>(
-        providers: &'a [&'a (dyn Provider)],
+        providers: &'a [&'a dyn Provider],
         config: GeneratePlanOptions,
     ) -> NixpacksBuildPlanGenerator<'a> {
         NixpacksBuildPlanGenerator { providers, config }

src/lib.rs

@@ -26,14 +26,20 @@ mod turborepo;
 pub const NODE_OVERLAY: &str = "https://github.com/railwayapp/nix-npm-overlay/archive/main.tar.gz";
 
 // unlike package managers, {node,bun} versions are pinned to a particular nixpacks release
-const NODE_NIXPKGS_ARCHIVE: &str = "ffeebf0acf3ae8b29f8c7049cd911b9636efd7e7";
-const BUN_NIXPKGS_ARCHIVE: &str = "5a0711127cd8b916c3d3128f473388c8c79df0da";
-
-// We need to use a specific commit hash for Node versions <16 since it is EOL in the latest Nix packages
-const NODE_LT_16_ARCHIVE: &str = "bf744fe90419885eefced41b3e5ae442d732712d";
+const BUN_NIXPKGS_ARCHIVE: &str = "31fb21469e34b6b5c7be77b9a35bae43d0c598e9";
 
 const DEFAULT_NODE_VERSION: u32 = 18;
-const AVAILABLE_NODE_VERSIONS: &[u32] = &[14, 16, 18, 20, 22, 23];
+
+// From: https://lazamar.co.uk/nix-versions/?channel=nixpkgs-unstable&package=nodejs
+// Maps Node version to nixpkgs archive hash
+const AVAILABLE_NODE_VERSIONS: &[(u32, &str)] = &[
+    (14, "bf744fe90419885eefced41b3e5ae442d732712d"), // EOL version, older nixpkgs
+    (16, "bf744fe90419885eefced41b3e5ae442d732712d"), // EOL version, older nixpkgs
+    (18, "ffeebf0acf3ae8b29f8c7049cd911b9636efd7e7"),
+    (20, "ffeebf0acf3ae8b29f8c7049cd911b9636efd7e7"),
+    (22, "e6f23dc08d3624daab7094b701aa3954923c6bbb"),
+    (24, "23f9169c4ccce521379e602cc82ed873a1f1b52b"),
+];
 
 const YARN_CACHE_DIR: &str = "/usr/local/share/.cache/yarn/v6";
 const PNPM_CACHE_DIR: &str = "/root/.local/share/pnpm/store/v3";
@@ -502,15 +508,27 @@ impl NodeProvider {
         let package_json: PackageJson = app.read_json("package.json").unwrap_or_default();
         let package_manager = NodeProvider::get_package_manager(app);
         let node_pkg = NodeProvider::get_nix_node_pkg(&package_json, app, &Environment::default())?;
-        let uses_le_16 = node_pkg.name.contains("14") || node_pkg.name.contains("16");
 
-        if uses_le_16 {
-            Ok(NODE_LT_16_ARCHIVE.to_string())
-        } else if package_manager == "bun" {
-            Ok(BUN_NIXPKGS_ARCHIVE.to_string())
-        } else {
-            Ok(NODE_NIXPKGS_ARCHIVE.to_string())
+        // Bun uses a separate archive
+        if package_manager == "bun" {
+            return Ok(BUN_NIXPKGS_ARCHIVE.to_string());
         }
+
+        // Extract version number from package name (e.g., "nodejs_18" -> 18)
+        let version = node_pkg
+            .name
+            .strip_prefix("nodejs_")
+            .and_then(|v| v.parse::<u32>().ok())
+            .unwrap_or(DEFAULT_NODE_VERSION);
+
+        // Look up the archive for this version
+        let archive = version_number_to_archive(version).unwrap_or_else(|| {
+            // Fallback to default version's archive
+            version_number_to_archive(DEFAULT_NODE_VERSION)
+                .expect("Default node version must exist in AVAILABLE_NODE_VERSIONS")
+        });
+
+        Ok(archive.to_string())
     }
 
     /// Returns the nodejs nix package and the appropriate package manager nix image.
@@ -529,16 +547,35 @@ impl NodeProvider {
         pkgs.push(node_pkg);
 
         if package_manager == "pnpm" {
-            let lockfile = app.read_file("pnpm-lock.yaml").unwrap_or_default();
-            if lockfile.starts_with("lockfileVersion: 5.3") {
-                pm_pkg = Pkg::new("pnpm-6_x");
-            } else if lockfile.starts_with("lockfileVersion: 5.4") {
-                pm_pkg = Pkg::new("pnpm-7_x");
-            } else if lockfile.starts_with("lockfileVersion: '6.0'") {
-                pm_pkg = Pkg::new("pnpm-8_x");
+            // First, try to determine version from packageManager field (for corepack)
+            if let Some(ref pkg_manager_field) = package_json.package_manager {
+                if let Some(version_str) = pkg_manager_field.strip_prefix("pnpm@") {
+                    // Parse major version from "[email protected]" -> 9
+                    if let Some(major_version) = version_str.split('.').next() {
+                        if let Ok(major) = major_version.parse::<u32>() {
+                            pm_pkg = match major {
+                                6 => Pkg::new("pnpm-6_x"),
+                                7 => Pkg::new("pnpm-7_x"),
+                                8 => Pkg::new("pnpm-8_x"),
+                                9 => Pkg::new("pnpm-9_x"),
+                                10 => Pkg::new("pnpm-10_x"),
+                                _ => {
+                                    // For unknown versions, try lockfile detection
+                                    NodeProvider::get_pnpm_package_from_lockfile(app)
+                                }
+                            };
+                        } else {
+                            pm_pkg = NodeProvider::get_pnpm_package_from_lockfile(app);
+                        }
+                    } else {
+                        pm_pkg = NodeProvider::get_pnpm_package_from_lockfile(app);
+                    }
+                } else {
+                    pm_pkg = NodeProvider::get_pnpm_package_from_lockfile(app);
+                }
             } else {
-                // Default to pnpm 9
-                pm_pkg = Pkg::new("pnpm-9_x");
+                // Fall back to lockfile-based detection
+                pm_pkg = NodeProvider::get_pnpm_package_from_lockfile(app);
             }
         } else if package_manager == "yarn" {
             pm_pkg = Pkg::new("yarn-1_x");
@@ -647,6 +684,20 @@ impl NodeProvider {
         all_deps
     }
 
+    fn get_pnpm_package_from_lockfile(app: &App) -> Pkg {
+        let lockfile = app.read_file("pnpm-lock.yaml").unwrap_or_default();
+        if lockfile.starts_with("lockfileVersion: 5.3") {
+            Pkg::new("pnpm-6_x")
+        } else if lockfile.starts_with("lockfileVersion: 5.4") {
+            Pkg::new("pnpm-7_x")
+        } else if lockfile.starts_with("lockfileVersion: '6.0'") {
+            Pkg::new("pnpm-8_x")
+        } else {
+            // lockfileVersion '9.0' and unknown versions default to pnpm 9
+            Pkg::new("pnpm-9_x")
+        }
+    }
+
     pub fn cache_tsbuildinfo_file(app: &App, build: &mut Phase) {
         let mut ts_config: TsConfigJson = app.read_json("tsconfig.json").unwrap_or_default();
         if let Some(ref extends) = ts_config.extends {
@@ -682,8 +733,19 @@ impl NodeProvider {
     }
 }
 
+fn version_number_to_archive(version: u32) -> Option<&'static str> {
+    AVAILABLE_NODE_VERSIONS
+        .iter()
+        .find(|(ver, _archive)| *ver == version)
+        .map(|(_ver, archive)| *archive)
+}
+
 fn version_number_to_pkg(version: u32) -> String {
-    if AVAILABLE_NODE_VERSIONS.contains(&version) {
+    let version_exists = AVAILABLE_NODE_VERSIONS
+        .iter()
+        .any(|(ver, _archive)| *ver == version);
+
+    if version_exists {
         format!("nodejs_{version}")
     } else {
         format!("nodejs_{DEFAULT_NODE_VERSION}")
@@ -698,16 +760,17 @@ fn parse_node_version_into_pkg(node_version: &str) -> String {
     });
     let mut available_lts_node_versions = AVAILABLE_NODE_VERSIONS
         .iter()
-        .filter(|v| *v % 2 == 0)
-        .collect::<Vec<_>>();
+        .map(|(ver, _archive)| *ver)
+        .filter(|v| v % 2 == 0)
+        .collect::<Vec<u32>>();
 
     // use newest node version first
     available_lts_node_versions.sort_by(|a, b| b.cmp(a));
     for version_number in available_lts_node_versions {
         let version_range_string = format!("{version_number}.x.x");
         let version_range: Range = version_range_string.parse().unwrap();
         if version_range.allows_any(&range) {
-            return version_number_to_pkg(*version_number);
+            return version_number_to_pkg(version_number);
         }
     }
     default_node_pkg_name
@@ -799,7 +862,7 @@ mod test {
                 &App::new("examples/node")?,
                 &Environment::default()
             )?,
-            Pkg::new(version_number_to_pkg(22).as_str())
+            Pkg::new(version_number_to_pkg(24).as_str())
         );
 
         Ok(())

src/nixpacks/plan/generator.rs

@@ -45,16 +45,6 @@ pub struct Configuration {
     pub production: Option<Value>,
 }
 
-#[derive(Debug, Serialize, PartialEq, Eq, Deserialize)]
-pub struct PackageJsonNx {
-    pub nx: Option<PackageJsonNxTargets>,
-}
-
-#[derive(Debug, Serialize, PartialEq, Eq, Deserialize)]
-pub struct PackageJsonNxTargets {
-    pub targets: Option<Targets>,
-}
-
 pub struct Nx {}
 
 const NX_APP_NAME_ENV_VAR: &str = "NX_APP_NAME";

src/providers/node/mod.rs

@@ -0,0 +1,55 @@
+---
+source: tests/generate_plan_tests.rs
+expression: plan
+---
+{
+  "providers": [],
+  "buildImage": "[build_image]",
+  "variables": {
+    "CI": "true",
+    "NIXPACKS_METADATA": "node",
+    "NODE_ENV": "production",
+    "NPM_CONFIG_PRODUCTION": "false"
+  },
+  "phases": {
+    "build": {
+      "name": "build",
+      "dependsOn": [
+        "install"
+      ],
+      "cacheDirectories": [
+        "node_modules/.cache"
+      ]
+    },
+    "install": {
+      "name": "install",
+      "dependsOn": [
+        "setup"
+      ],
+      "cmds": [
+        "npm install -g [email protected] && corepack enable",
+        "pnpm i --frozen-lockfile"
+      ],
+      "cacheDirectories": [
+        "/root/.local/share/pnpm/store/v3"
+      ],
+      "paths": [
+        "/app/node_modules/.bin"
+      ]
+    },
+    "setup": {
+      "name": "setup",
+      "nixPkgs": [
+        "nodejs_24",
+        "pnpm-10_x"
+      ],
+      "nixOverlays": [
+        "https://github.com/railwayapp/nix-npm-overlay/archive/main.tar.gz"
+      ],
+      "nixpkgsArchive": "[archive]"
+    }
+  },
+  "start": {
+    "cmd": "pnpm run start"
+  }
+}

src/providers/node/nx.rs

@@ -43,7 +43,7 @@ expression: plan
     "setup": {
       "name": "setup",
       "nixPkgs": [
-        "nodejs_22",
+        "nodejs_24",
         "pnpm-9_x"
       ],
       "nixOverlays": [