fix(install): handle transitive folder dependencies

src/install/lockfile.zig

@@ -320,12 +320,12 @@ pub const Tree = struct {
 
     pub fn toTree(out: External) Tree {
         return .{
-            .id = @as(Id, @bitCast(out[0..4].*)),
-            .dependency_id = @as(Id, @bitCast(out[4..8].*)),
-            .parent = @as(Id, @bitCast(out[8..12].*)),
+            .id = @bitCast(out[0..4].*),
+            .dependency_id = @bitCast(out[4..8].*),
+            .parent = @bitCast(out[8..12].*),
             .dependencies = .{
-                .off = @as(u32, @bitCast(out[12..16].*)),
-                .len = @as(u32, @bitCast(out[16..20].*)),
+                .off = @bitCast(out[12..16].*),
+                .len = @bitCast(out[16..20].*),
             },
         };
     }
@@ -474,7 +474,7 @@ pub const Tree = struct {
     const Builder = struct {
         allocator: Allocator,
         name_hashes: []const PackageNameHash,
-        list: ArrayList = .{},
+        list: bun.MultiArrayList(Entry) = .{},
         resolutions: []const PackageID,
         dependencies: []const Dependency,
         resolution_lists: []const Lockfile.DependencyIDSlice,
@@ -504,8 +504,6 @@ pub const Tree = struct {
             dependencies: Lockfile.DependencyIDList,
         };
 
-        pub const ArrayList = bun.MultiArrayList(Entry);
-
         /// Flatten the multi-dimensional ArrayList of package IDs into a single easily serializable array
         pub fn clean(this: *Builder) !DependencyIDList {
             const end = @as(Id, @truncate(this.list.len));
@@ -565,6 +563,8 @@ pub const Tree = struct {
         const next: *Tree = &trees[builder.list.len - 1];
         const name_hashes: []const PackageNameHash = builder.name_hashes;
         const max_package_id = @as(PackageID, @truncate(name_hashes.len));
+        const resolutions = builder.lockfile.packages.items(.resolution);
+
         var dep_id = resolution_list.off;
         const end = dep_id + resolution_list.len;
 
@@ -574,16 +574,19 @@ pub const Tree = struct {
             if (pid >= max_package_id) continue;
 
             const dependency = builder.dependencies[dep_id];
-
-            const destination = try next.hoistDependency(
-                true,
-                pid,
-                dep_id,
-                &dependency,
-                dependency_lists,
-                trees,
-                builder,
-            );
+            // Do not hoist folder dependencies
+            const destination = if (resolutions[pid].tag == .folder)
+                next.id
+            else
+                try next.hoistDependency(
+                    true,
+                    pid,
+                    dep_id,
+                    &dependency,
+                    dependency_lists,
+                    trees,
+                    builder,
+                );
 
             switch (destination) {
                 Tree.dependency_loop, Tree.hoisted => continue,
@@ -821,15 +824,51 @@ pub fn clean(
 }
 
 /// Is this a direct dependency of the workspace root package.json?
-pub fn isWorkspaceRootDependency(this: *Lockfile, id: DependencyID) bool {
+pub fn isWorkspaceRootDependency(this: *const Lockfile, id: DependencyID) bool {
     return this.packages.items(.dependencies)[0].contains(id);
 }
 
 /// Is this a direct dependency of the workspace the install is taking place in?
-pub fn isRootDependency(this: *Lockfile, manager: *PackageManager, id: DependencyID) bool {
+pub fn isRootDependency(this: *const Lockfile, manager: *PackageManager, id: DependencyID) bool {
     return this.packages.items(.dependencies)[manager.root_package_id.get(this, manager.workspace_name_hash)].contains(id);
 }
 
+/// Is this a direct dependency of any workspace (including workspace root)?
+/// TODO make this faster by caching the workspace package ids
+pub fn isWorkspaceDependency(this: *const Lockfile, id: DependencyID) bool {
+    const packages = this.packages.slice();
+    const resolutions = packages.items(.resolution);
+    const dependencies_lists = packages.items(.dependencies);
+    for (resolutions, dependencies_lists) |resolution, dependencies| {
+        if (resolution.tag != .workspace and resolution.tag != .root) continue;
+        if (dependencies.contains(id)) return true;
+    }
+
+    return false;
+}
+
+/// Does this tree id belong to a workspace (including workspace root)?
+pub fn isWorkspaceTreeId(this: *const Lockfile, id: Tree.Id) bool {
+    return id == 0 or this.buffers.dependencies.items[this.buffers.trees.items[id].dependency_id].behavior.isWorkspaceOnly();
+}
+
+pub fn getWorkspacePackageID(this: *const Lockfile, workspace_name_hash: ?PackageNameHash) PackageID {
+    return if (workspace_name_hash) |workspace_name_hash_| brk: {
+        const packages = this.packages.slice();
+        const name_hashes = packages.items(.name_hash);
+        const resolutions = packages.items(.resolution);
+        const metas = packages.items(.meta);
+        for (resolutions, name_hashes, metas) |res, name_hash, meta| {
+            if (res.tag == .workspace and name_hash == workspace_name_hash_) {
+                break :brk meta.id;
+            }
+        }
+
+        // should not hit this, default to root just in case
+        break :brk 0;
+    } else 0;
+}
+
 pub fn cleanWithLogger(
     old: *Lockfile,
     manager: *PackageManager,
@@ -1025,23 +1064,6 @@ pub fn cleanWithLogger(
     return new;
 }
 
-pub fn getWorkspacePackageID(this: *const Lockfile, workspace_name_hash: ?PackageNameHash) PackageID {
-    return if (workspace_name_hash) |workspace_name_hash_| brk: {
-        const packages = this.packages.slice();
-        const name_hashes = packages.items(.name_hash);
-        const resolutions = packages.items(.resolution);
-        const metas = packages.items(.meta);
-        for (resolutions, name_hashes, metas) |res, name_hash, meta| {
-            if (res.tag == .workspace and name_hash == workspace_name_hash_) {
-                break :brk meta.id;
-            }
-        }
-
-        // should not hit this, default to root just in case
-        break :brk 0;
-    } else 0;
-}
-
 pub const MetaHashFormatter = struct {
     meta_hash: *const MetaHash,
 

src/install/patch_install.zig

@@ -348,9 +348,10 @@ pub const PatchTask = struct {
             .package_version = resolution_label,
             // dummy value
             .node_modules = &dummy_node_modules,
+            .lockfile = this.manager.lockfile,
         };
 
-        switch (pkg_install.installImpl(true, system_tmpdir, .copyfile)) {
+        switch (pkg_install.installImpl(true, system_tmpdir, .copyfile, this.callback.apply.resolution.tag)) {
             .success => {},
             .fail => |reason| {
                 return try log.addErrorFmtNoLoc(

src/sys.zig

@@ -105,6 +105,7 @@ pub const Tag = enum(u8) {
     rename,
     stat,
     symlink,
+    symlinkat,
     unlink,
     utimes,
     write,
@@ -1745,9 +1746,19 @@ pub fn chown(path: [:0]const u8, uid: os.uid_t, gid: os.gid_t) Maybe(void) {
     }
 }
 
-pub fn symlink(from: [:0]const u8, to: [:0]const u8) Maybe(void) {
+pub fn symlink(target: [:0]const u8, dest: [:0]const u8) Maybe(void) {
     while (true) {
-        if (Maybe(void).errnoSys(sys.symlink(from, to), .symlink)) |err| {
+        if (Maybe(void).errnoSys(sys.symlink(target, dest), .symlink)) |err| {
+            if (err.getErrno() == .INTR) continue;
+            return err;
+        }
+        return Maybe(void).success;
+    }
+}
+
+pub fn symlinkat(target: [:0]const u8, dirfd: bun.FileDescriptor, dest: [:0]const u8) Maybe(void) {
+    while (true) {
+        if (Maybe(void).errnoSys(sys.symlinkat(target, dirfd.cast(), dest), .symlinkat)) |err| {
             if (err.getErrno() == .INTR) continue;
             return err;
         }
@@ -1774,12 +1785,14 @@ pub const WindowsSymlinkOptions = packed struct {
     pub var has_failed_to_create_symlink = false;
 };
 
-pub fn symlinkOrJunctionOnWindows(dest: [:0]const u8, target: [:0]const u8) Maybe(void) {
+pub fn symlinkOrJunction(dest: [:0]const u8, target: [:0]const u8) Maybe(void) {
+    if (comptime !Environment.isWindows) @compileError("symlinkOrJunction is windows only");
+
     if (!WindowsSymlinkOptions.has_failed_to_create_symlink) {
         var sym16: bun.WPathBuffer = undefined;
         var target16: bun.WPathBuffer = undefined;
-        const sym_path = bun.strings.toNTPath(&sym16, dest);
-        const target_path = bun.strings.toNTPath(&target16, target);
+        const sym_path = bun.strings.toWPathNormalizeAutoExtend(&sym16, dest);
+        const target_path = bun.strings.toWPathNormalizeAutoExtend(&target16, target);
         switch (symlinkW(sym_path, target_path, .{ .directory = true })) {
             .result => {
                 return Maybe(void).success;

test/cli/install/bun-add.test.ts

@@ -169,6 +169,7 @@ for (const pathType of ["absolute", "relative"]) {
         "",
         "1 package installed",
       ]);
+
       expect(await exited).toBe(0);
     },
   );
@@ -1671,17 +1672,17 @@ it("should add dependencies to workspaces directly", async () => {
     "package.json",
   ]);
   expect(await file(join(package_dir, "package.json")).text()).toEqual(bar_package);
-  expect(await readdirSorted(join(package_dir, "moo"))).toEqual(["bunfig.toml", "package.json"]);
+  expect(await readdirSorted(join(package_dir, "moo"))).toEqual(["bunfig.toml", "node_modules", "package.json"]);
+  expect(await readdirSorted(join(package_dir, "moo", "node_modules", "foo"))).toEqual(["package.json"]);
+  expect(await file(join(package_dir, "moo", "node_modules", "foo", "package.json")).text()).toEqual(foo_package);
   expect(await file(join(package_dir, "moo", "package.json")).json()).toEqual({
     name: "moo",
     version: "0.3.0",
     dependencies: {
       foo: `file:${add_path.replace(/\\/g, "/")}`,
     },
   });
-  expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "foo", "moo"]);
-  expect(await readdirSorted(join(package_dir, "node_modules", "foo"))).toEqual(["package.json"]);
-  expect(await file(join(package_dir, "node_modules", "foo", "package.json")).text()).toEqual(foo_package);
+  expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "moo"]);
 });
 
 it("should redirect 'install --save X' to 'add'", async () => {