feat(turborepo): support Bun

cli/internal/ffi/ffi.go

@@ -220,6 +220,8 @@ func toPackageManager(packageManager string) ffi_proto.PackageManager {
 		return ffi_proto.PackageManager_PNPM
 	case "yarn":
 		return ffi_proto.PackageManager_YARN
+	case "bun":
+		return ffi_proto.PackageManager_BUN
 	default:
 		panic(fmt.Sprintf("Invalid package manager string: %s", packageManager))
 	}

cli/internal/lockfile/bun_lockfile.go

@@ -0,0 +1,38 @@
+package lockfile
+
+import (
+	"github.com/vercel/turbo/cli/internal/turbopath"
+)
+
+// BunLockfile representation of bun lockfile
+type BunLockfile struct {
+	contents []byte
+}
+
+var _ Lockfile = (*BunLockfile)(nil)
+
+// ResolvePackage Given a package and version returns the key, resolved version, and if it was found
+func (l *BunLockfile) ResolvePackage(_ turbopath.AnchoredUnixPath, _ string, _ string) (Package, error) {
+	// This is only used when doing calculating the transitive deps, but Rust
+	// implementations do this calculation on the Rust side.
+	panic("Unreachable")
+}
+
+// AllDependencies Given a lockfile key return all (dev/optional/peer) dependencies of that package
+func (l *BunLockfile) AllDependencies(_ string) (map[string]string, bool) {
+	// This is only used when doing calculating the transitive deps, but Rust
+	// implementations do this calculation on the Rust side.
+	panic("Unreachable")
+}
+
+// DecodeBunLockfile Takes the contents of a bun lockfile and returns a struct representation
+func DecodeBunLockfile(contents []byte) (*BunLockfile, error) {
+	return &BunLockfile{contents: contents}, nil
+}
+
+// GlobalChange checks if there are any differences between lockfiles that would completely invalidate
+// the cache.
+func (l *BunLockfile) GlobalChange(other Lockfile) bool {
+	_, ok := other.(*BunLockfile)
+	return !ok
+}

cli/internal/lockfile/lockfile.go

@@ -78,6 +78,9 @@ func AllTransitiveClosures(
 	if lf, ok := lockFile.(*YarnLockfile); ok {
 		return rustTransitiveDeps(lf.contents, "yarn", workspaces, nil)
 	}
+	if lf, ok := lockFile.(*BunLockfile); ok {
+		return rustTransitiveDeps(lf.contents, "bun", workspaces, nil)
+	}
 
 	g := new(errgroup.Group)
 	c := make(chan closureMsg, len(workspaces))

cli/internal/packagemanager/berry.go

@@ -9,12 +9,14 @@ import (
 	"github.com/vercel/turbo/cli/internal/turbopath"
 )
 
+const berryLockfile = "yarn.lock"
+
 var nodejsBerry = PackageManager{
 	Name:         "nodejs-berry",
 	Slug:         "yarn",
 	Command:      "yarn",
 	Specfile:     "package.json",
-	Lockfile:     "yarn.lock",
+	Lockfile:     berryLockfile,
 	PackageDir:   "node_modules",
 	ArgSeparator: func(_userArgs []string) []string { return nil },
 
@@ -43,6 +45,18 @@ var nodejsBerry = PackageManager{
 		return true, nil
 	},
 
+	GetLockfileName: func(_ turbopath.AbsoluteSystemPath) string {
+		return berryLockfile
+	},
+
+	GetLockfilePath: func(projectDirectory turbopath.AbsoluteSystemPath) turbopath.AbsoluteSystemPath {
+		return projectDirectory.UntypedJoin(berryLockfile)
+	},
+
+	GetLockfileContents: func(projectDirectory turbopath.AbsoluteSystemPath) ([]byte, error) {
+		return projectDirectory.UntypedJoin(berryLockfile).ReadFile()
+	},
+
 	UnmarshalLockfile: func(rootPackageJSON *fs.PackageJSON, contents []byte) (lockfile.Lockfile, error) {
 		var resolutions map[string]string
 		if untypedResolutions, ok := rootPackageJSON.RawJSON["resolutions"]; ok {

cli/internal/packagemanager/bun.go

@@ -0,0 +1,81 @@
+package packagemanager
+
+import (
+	"fmt"
+	"os/exec"
+
+	"github.com/vercel/turbo/cli/internal/fs"
+	"github.com/vercel/turbo/cli/internal/lockfile"
+	"github.com/vercel/turbo/cli/internal/turbopath"
+)
+
+const command = "bun"
+const bunLockfile = "bun.lockb"
+
+func getLockfilePath(rootPath turbopath.AbsoluteSystemPath) turbopath.AbsoluteSystemPath {
+	return rootPath.UntypedJoin(bunLockfile)
+}
+
+var nodejsBun = PackageManager{
+	Name:       "nodejs-bun",
+	Slug:       "bun",
+	Command:    command,
+	Specfile:   "package.json",
+	Lockfile:   bunLockfile,
+	PackageDir: "node_modules",
+	ArgSeparator: func(userArgs []string) []string {
+		// Bun swallows a single "--" token. If the user is passing "--", we need
+		// to prepend our own so that the user's doesn't get swallowed. If they are not
+		// passing their own, we don't need the "--" token and can avoid the warning.
+		for _, arg := range userArgs {
+			if arg == "--" {
+				return []string{"--"}
+			}
+		}
+		return nil
+	},
+
+	getWorkspaceGlobs: func(rootpath turbopath.AbsoluteSystemPath) ([]string, error) {
+		pkg, err := fs.ReadPackageJSON(rootpath.UntypedJoin("package.json"))
+		if err != nil {
+			return nil, fmt.Errorf("package.json: %w", err)
+		}
+		if len(pkg.Workspaces) == 0 {
+			return nil, fmt.Errorf("package.json: no workspaces found. Turborepo requires Bun workspaces to be defined in the root package.json")
+		}
+		return pkg.Workspaces, nil
+	},
+
+	getWorkspaceIgnores: func(pm PackageManager, rootpath turbopath.AbsoluteSystemPath) ([]string, error) {
+		// Matches upstream values:
+		// Key code: https://github.com/oven-sh/bun/blob/f267c1d097923a2d2992f9f60a6dd365fe706512/src/install/lockfile.zig#L3057
+		return []string{
+			"**/node_modules",
+			"**/.git",
+		}, nil
+	},
+
+	canPrune: func(cwd turbopath.AbsoluteSystemPath) (bool, error) {
+		return false, nil
+	},
+
+	GetLockfileName: func(rootPath turbopath.AbsoluteSystemPath) string {
+		return bunLockfile
+	},
+
+	GetLockfilePath: func(rootPath turbopath.AbsoluteSystemPath) turbopath.AbsoluteSystemPath {
+		return getLockfilePath(rootPath)
+	},
+
+	GetLockfileContents: func(projectDirectory turbopath.AbsoluteSystemPath) ([]byte, error) {
+		lockfilePath := getLockfilePath(projectDirectory)
+		cmd := exec.Command(command, lockfilePath.ToString())
+		cmd.Dir = projectDirectory.ToString()
+
+		return cmd.Output()
+	},
+
+	UnmarshalLockfile: func(_rootPackageJSON *fs.PackageJSON, contents []byte) (lockfile.Lockfile, error) {
+		return lockfile.DecodeBunLockfile(contents)
+	},
+}

cli/internal/packagemanager/npm.go

@@ -8,12 +8,14 @@ import (
 	"github.com/vercel/turbo/cli/internal/turbopath"
 )
 
+const npmLockfile = "package-lock.json"
+
 var nodejsNpm = PackageManager{
 	Name:         "nodejs-npm",
 	Slug:         "npm",
 	Command:      "npm",
 	Specfile:     "package.json",
-	Lockfile:     "package-lock.json",
+	Lockfile:     npmLockfile,
 	PackageDir:   "node_modules",
 	ArgSeparator: func(_userArgs []string) []string { return []string{"--"} },
 
@@ -42,6 +44,18 @@ var nodejsNpm = PackageManager{
 		return true, nil
 	},
 
+	GetLockfileName: func(_ turbopath.AbsoluteSystemPath) string {
+		return npmLockfile
+	},
+
+	GetLockfilePath: func(projectDirectory turbopath.AbsoluteSystemPath) turbopath.AbsoluteSystemPath {
+		return projectDirectory.UntypedJoin(npmLockfile)
+	},
+
+	GetLockfileContents: func(projectDirectory turbopath.AbsoluteSystemPath) ([]byte, error) {
+		return projectDirectory.UntypedJoin(npmLockfile).ReadFile()
+	},
+
 	UnmarshalLockfile: func(_rootPackageJSON *fs.PackageJSON, contents []byte) (lockfile.Lockfile, error) {
 		return lockfile.DecodeNpmLockfile(contents)
 	},