1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
package packagemanager
import (
"fmt"
"os/exec"
"strings"
"github.com/Masterminds/semver"
"github.com/pkg/errors"
"github.com/vercel/turbo/cli/internal/fs"
"github.com/vercel/turbo/cli/internal/lockfile"
"github.com/vercel/turbo/cli/internal/turbopath"
"github.com/vercel/turbo/cli/internal/util"
)
var nodejsBerry = PackageManager{
Name: "nodejs-berry",
Slug: "yarn",
Command: "yarn",
Specfile: "package.json",
Lockfile: "yarn.lock",
PackageDir: "node_modules",
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 Yarn 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/yarnpkg/berry/blob/8e0c4b897b0881878a1f901230ea49b7c8113fbe/packages/yarnpkg-core/sources/Workspace.ts#L64-L70
return []string{
"**/node_modules",
"**/.git",
"**/.yarn",
}, nil
},
canPrune: func(cwd turbopath.AbsoluteSystemPath) (bool, error) {
if isNMLinker, err := util.IsNMLinker(cwd.ToStringDuringMigration()); err != nil {
return false, errors.Wrap(err, "could not determine if yarn is using `nodeLinker: node-modules`")
} else if !isNMLinker {
return false, errors.New("only yarn v2/v3 with `nodeLinker: node-modules` is supported at this time")
}
return true, nil
},
// Versions newer than 2.0 are berry, and before that we simply call them yarn.
Matches: func(manager string, version string) (bool, error) {
if manager != "yarn" {
return false, nil
}
v, err := semver.NewVersion(version)
if err != nil {
return false, fmt.Errorf("could not parse yarn version: %w", err)
}
// -0 allows pre-releases versions to be considered valid
c, err := semver.NewConstraint(">=2.0.0-0")
if err != nil {
return false, fmt.Errorf("could not create constraint: %w", err)
}
return c.Check(v), nil
},
// Detect for berry needs to identify which version of yarn is running on the system.
// Further, berry can be configured in an incompatible way, so we check for compatibility here as well.
detect: func(projectDirectory turbopath.AbsoluteSystemPath, packageManager *PackageManager) (bool, error) {
specfileExists := projectDirectory.UntypedJoin(packageManager.Specfile).FileExists()
lockfileExists := projectDirectory.UntypedJoin(packageManager.Lockfile).FileExists()
// Short-circuit, definitely not Yarn.
if !specfileExists || !lockfileExists {
return false, nil
}
cmd := exec.Command("yarn", "--version")
cmd.Dir = projectDirectory.ToString()
out, err := cmd.Output()
if err != nil {
return false, fmt.Errorf("could not detect yarn version: %w", err)
}
// See if we're a match when we compare these two things.
matches, _ := packageManager.Matches(packageManager.Slug, string(out))
// Short-circuit, definitely not Berry because version number says we're Yarn.
if !matches {
return false, nil
}
// We're Berry!
// Check for supported configuration.
isNMLinker, err := util.IsNMLinker(projectDirectory.ToStringDuringMigration())
if err != nil {
// Failed to read the linker state, so we treat an unknown configuration as a failure.
return false, fmt.Errorf("could not check if yarn is using nm-linker: %w", err)
} else if !isNMLinker {
// Not using nm-linker, so unsupported configuration.
return false, fmt.Errorf("only yarn nm-linker is supported")
}
// Berry, supported configuration.
return true, nil
},
UnmarshalLockfile: func(_rootPackageJSON *fs.PackageJSON, contents []byte) (lockfile.Lockfile, error) {
return lockfile.DecodeBerryLockfile(contents)
},
prunePatches: func(pkgJSON *fs.PackageJSON, patches []turbopath.AnchoredUnixPath) error {
pkgJSON.Mu.Lock()
defer pkgJSON.Mu.Unlock()
keysToDelete := []string{}
resolutions, ok := pkgJSON.RawJSON["resolutions"].(map[string]interface{})
if !ok {
return fmt.Errorf("Invalid structure for resolutions field in package.json")
}
for dependency, untypedPatch := range resolutions {
inPatches := false
patch, ok := untypedPatch.(string)
if !ok {
return fmt.Errorf("Expected value of %s in package.json to be a string, got %v", dependency, untypedPatch)
}
for _, wantedPatch := range patches {
if strings.HasSuffix(patch, wantedPatch.ToString()) {
inPatches = true
break
}
}
// We only want to delete unused patches as they are the only ones that throw if unused
if !inPatches && strings.HasSuffix(patch, ".patch") {
keysToDelete = append(keysToDelete, dependency)
}
}
for _, key := range keysToDelete {
delete(resolutions, key)
}
return nil
},
}
|