Skip to content

Commit 9074391

Browse files
NicholasLYangNicholasLYang
committed
Renaming query
1 parent 8998e89 commit 9074391

File tree

2 files changed

+154
-41
lines changed

2 files changed

+154
-41
lines changed

‎crates/turborepo-lib/src/query.rs

+132-36
Original file line numberDiff line numberDiff line change
@@ -44,40 +44,56 @@ struct Package {
4444
}
4545

4646
impl Package {
47-
fn immediate_dependents_count(&self) -> usize {
47+
fn direct_dependents_count(&self) -> usize {
4848
self.run
4949
.pkg_dep_graph()
5050
.immediate_ancestors(&PackageNode::Workspace(self.name.clone()))
5151
.map_or(0, |pkgs| pkgs.len())
5252
}
5353

54-
fn immediate_dependencies_count(&self) -> usize {
54+
fn direct_dependencies_count(&self) -> usize {
5555
self.run
5656
.pkg_dep_graph()
5757
.immediate_dependencies(&PackageNode::Workspace(self.name.clone()))
5858
.map_or(0, |pkgs| pkgs.len())
5959
}
6060

61-
fn dependent_count(&self) -> usize {
61+
fn indirect_dependents_count(&self) -> usize {
6262
let node: PackageNode = PackageNode::Workspace(self.name.clone());
6363

64-
self.run.pkg_dep_graph().ancestors(&node).len()
64+
self.run.pkg_dep_graph().ancestors(&node).len() - self.direct_dependents_count()
6565
}
6666

67-
fn dependency_count(&self) -> usize {
67+
fn indirect_dependencies_count(&self) -> usize {
6868
let node: PackageNode = PackageNode::Workspace(self.name.clone());
6969

70-
self.run.pkg_dep_graph().dependencies(&node).len()
70+
self.run.pkg_dep_graph().dependencies(&node).len() - self.direct_dependencies_count()
71+
}
72+
73+
fn all_dependents_count(&self) -> usize {
74+
self.run
75+
.pkg_dep_graph()
76+
.ancestors(&PackageNode::Workspace(self.name.clone()))
77+
.len()
78+
}
79+
80+
fn all_dependencies_count(&self) -> usize {
81+
self.run
82+
.pkg_dep_graph()
83+
.dependencies(&PackageNode::Workspace(self.name.clone()))
84+
.len()
7185
}
7286
}
7387

7488
#[derive(Enum, Copy, Clone, Eq, PartialEq, Debug)]
7589
enum PackageFields {
7690
Name,
77-
DependencyCount,
78-
DependentCount,
79-
ImmediateDependentCount,
80-
ImmediateDependencyCount,
91+
DirectDependencyCount,
92+
DirectDependentCount,
93+
IndirectDependentCount,
94+
IndirectDependencyCount,
95+
AllDependentCount,
96+
AllDependencyCount,
8197
}
8298

8399
#[derive(InputObject)]
@@ -107,89 +123,125 @@ impl PackagePredicate {
107123
fn check_equals(pkg: &Package, field: &PackageFields, value: &Any) -> bool {
108124
match (field, &value.0) {
109125
(PackageFields::Name, Value::String(name)) => pkg.name.as_ref() == name,
110-
(PackageFields::DependencyCount, Value::Number(n)) => {
126+
(PackageFields::DirectDependencyCount, Value::Number(n)) => {
111127
let Some(n) = n.as_u64() else {
112128
return false;
113129
};
114-
pkg.dependency_count() == n as usize
130+
pkg.direct_dependencies_count() == n as usize
115131
}
116-
(PackageFields::DependentCount, Value::Number(n)) => {
132+
(PackageFields::DirectDependentCount, Value::Number(n)) => {
117133
let Some(n) = n.as_u64() else {
118134
return false;
119135
};
120-
pkg.dependent_count() == n as usize
136+
pkg.direct_dependents_count() == n as usize
121137
}
122-
(PackageFields::ImmediateDependentCount, Value::Number(n)) => {
138+
(PackageFields::IndirectDependentCount, Value::Number(n)) => {
123139
let Some(n) = n.as_u64() else {
124140
return false;
125141
};
126-
pkg.immediate_dependents_count() == n as usize
142+
pkg.indirect_dependents_count() == n as usize
127143
}
128-
(PackageFields::ImmediateDependencyCount, Value::Number(n)) => {
144+
(PackageFields::IndirectDependencyCount, Value::Number(n)) => {
129145
let Some(n) = n.as_u64() else {
130146
return false;
131147
};
132-
pkg.immediate_dependencies_count() == n as usize
148+
pkg.indirect_dependencies_count() == n as usize
149+
}
150+
(PackageFields::AllDependentCount, Value::Number(n)) => {
151+
let Some(n) = n.as_u64() else {
152+
return false;
153+
};
154+
pkg.all_dependents_count() == n as usize
155+
}
156+
(PackageFields::AllDependencyCount, Value::Number(n)) => {
157+
let Some(n) = n.as_u64() else {
158+
return false;
159+
};
160+
pkg.all_dependencies_count() == n as usize
133161
}
134162
_ => false,
135163
}
136164
}
137165

138166
fn check_greater_than(pkg: &Package, field: &PackageFields, value: &Any) -> bool {
139167
match (field, &value.0) {
140-
(PackageFields::DependencyCount, Value::Number(n)) => {
168+
(PackageFields::DirectDependencyCount, Value::Number(n)) => {
169+
let Some(n) = n.as_u64() else {
170+
return false;
171+
};
172+
pkg.direct_dependencies_count() > n as usize
173+
}
174+
(PackageFields::DirectDependentCount, Value::Number(n)) => {
141175
let Some(n) = n.as_u64() else {
142176
return false;
143177
};
144-
pkg.dependency_count() > n as usize
178+
pkg.direct_dependents_count() > n as usize
145179
}
146-
(PackageFields::DependentCount, Value::Number(n)) => {
180+
(PackageFields::IndirectDependentCount, Value::Number(n)) => {
147181
let Some(n) = n.as_u64() else {
148182
return false;
149183
};
150-
pkg.dependent_count() > n as usize
184+
pkg.indirect_dependents_count() > n as usize
151185
}
152-
(PackageFields::ImmediateDependentCount, Value::Number(n)) => {
186+
(PackageFields::IndirectDependencyCount, Value::Number(n)) => {
153187
let Some(n) = n.as_u64() else {
154188
return false;
155189
};
156-
pkg.immediate_dependents_count() > n as usize
190+
pkg.indirect_dependencies_count() > n as usize
157191
}
158-
(PackageFields::ImmediateDependencyCount, Value::Number(n)) => {
192+
(PackageFields::AllDependentCount, Value::Number(n)) => {
159193
let Some(n) = n.as_u64() else {
160194
return false;
161195
};
162-
pkg.immediate_dependencies_count() > n as usize
196+
pkg.all_dependents_count() > n as usize
197+
}
198+
(PackageFields::AllDependencyCount, Value::Number(n)) => {
199+
let Some(n) = n.as_u64() else {
200+
return false;
201+
};
202+
pkg.all_dependencies_count() > n as usize
163203
}
164204
_ => false,
165205
}
166206
}
167207

168208
fn check_less_than(pkg: &Package, field: &PackageFields, value: &Any) -> bool {
169209
match (field, &value.0) {
170-
(PackageFields::DependencyCount, Value::Number(n)) => {
210+
(PackageFields::DirectDependencyCount, Value::Number(n)) => {
171211
let Some(n) = n.as_u64() else {
172212
return false;
173213
};
174-
pkg.dependency_count() < n as usize
214+
pkg.direct_dependencies_count() < n as usize
175215
}
176-
(PackageFields::DependentCount, Value::Number(n)) => {
216+
(PackageFields::DirectDependentCount, Value::Number(n)) => {
177217
let Some(n) = n.as_u64() else {
178218
return false;
179219
};
180-
pkg.dependent_count() < n as usize
220+
pkg.direct_dependents_count() < n as usize
181221
}
182-
(PackageFields::ImmediateDependentCount, Value::Number(n)) => {
222+
(PackageFields::IndirectDependentCount, Value::Number(n)) => {
183223
let Some(n) = n.as_u64() else {
184224
return false;
185225
};
186-
pkg.immediate_dependents_count() < n as usize
226+
pkg.indirect_dependents_count() < n as usize
187227
}
188-
(PackageFields::ImmediateDependencyCount, Value::Number(n)) => {
228+
(PackageFields::IndirectDependencyCount, Value::Number(n)) => {
189229
let Some(n) = n.as_u64() else {
190230
return false;
191231
};
192-
pkg.immediate_dependencies_count() < n as usize
232+
pkg.indirect_dependencies_count() < n as usize
233+
}
234+
(PackageFields::AllDependentCount, Value::Number(n)) => {
235+
let Some(n) = n.as_u64() else {
236+
return false;
237+
};
238+
pkg.all_dependents_count() < n as usize
239+
}
240+
(PackageFields::AllDependencyCount, Value::Number(n)) => {
241+
let Some(n) = n.as_u64() else {
242+
return false;
243+
};
244+
pkg.all_dependencies_count() < n as usize
193245
}
194246
_ => false,
195247
}
@@ -319,7 +371,7 @@ impl Package {
319371
}
320372

321373
/// The upstream packages that have this package as a direct dependency
322-
async fn dependents(&self) -> Result<Vec<Package>, Error> {
374+
async fn direct_dependents(&self) -> Result<Vec<Package>, Error> {
323375
let node: PackageNode = PackageNode::Workspace(self.name.clone());
324376
Ok(self
325377
.run
@@ -331,11 +383,12 @@ impl Package {
331383
run: self.run.clone(),
332384
name: package.as_package_name().clone(),
333385
})
386+
.sorted_by(|a, b| a.name.cmp(&b.name))
334387
.collect())
335388
}
336389

337390
/// The downstream packages that directly depend on this package
338-
async fn dependencies(&self) -> Result<Vec<Package>, Error> {
391+
async fn direct_dependencies(&self) -> Result<Vec<Package>, Error> {
339392
let node: PackageNode = PackageNode::Workspace(self.name.clone());
340393
Ok(self
341394
.run
@@ -347,18 +400,55 @@ impl Package {
347400
run: self.run.clone(),
348401
name: package.as_package_name().clone(),
349402
})
403+
.sorted_by(|a, b| a.name.cmp(&b.name))
404+
.collect())
405+
}
406+
407+
async fn all_dependents(&self) -> Result<Vec<Package>, Error> {
408+
let node: PackageNode = PackageNode::Workspace(self.name.clone());
409+
Ok(self
410+
.run
411+
.pkg_dep_graph()
412+
.ancestors(&node)
413+
.iter()
414+
.map(|package| Package {
415+
run: self.run.clone(),
416+
name: package.as_package_name().clone(),
417+
})
418+
.sorted_by(|a, b| a.name.cmp(&b.name))
419+
.collect())
420+
}
421+
422+
async fn all_dependencies(&self) -> Result<Vec<Package>, Error> {
423+
let node: PackageNode = PackageNode::Workspace(self.name.clone());
424+
Ok(self
425+
.run
426+
.pkg_dep_graph()
427+
.dependencies(&node)
428+
.iter()
429+
.map(|package| Package {
430+
run: self.run.clone(),
431+
name: package.as_package_name().clone(),
432+
})
433+
.sorted_by(|a, b| a.name.cmp(&b.name))
350434
.collect())
351435
}
352436

353437
/// The downstream packages that depend on this package, indirectly
354438
async fn indirect_dependents(&self) -> Result<Vec<Package>, Error> {
355439
let node: PackageNode = PackageNode::Workspace(self.name.clone());
440+
let immediate_dependents = self
441+
.run
442+
.pkg_dep_graph()
443+
.immediate_ancestors(&node)
444+
.ok_or_else(|| Error::PackageNotFound(self.name.clone()))?;
356445

357446
Ok(self
358447
.run
359448
.pkg_dep_graph()
360449
.ancestors(&node)
361450
.iter()
451+
.filter(|package| !immediate_dependents.contains(*package))
362452
.map(|package| Package {
363453
run: self.run.clone(),
364454
name: package.as_package_name().clone(),
@@ -370,12 +460,18 @@ impl Package {
370460
/// The upstream packages that this package depends on, indirectly
371461
async fn indirect_dependencies(&self) -> Result<Vec<Package>, Error> {
372462
let node: PackageNode = PackageNode::Workspace(self.name.clone());
463+
let immediate_dependencies = self
464+
.run
465+
.pkg_dep_graph()
466+
.immediate_dependencies(&node)
467+
.ok_or_else(|| Error::PackageNotFound(self.name.clone()))?;
373468

374469
Ok(self
375470
.run
376471
.pkg_dep_graph()
377472
.dependencies(&node)
378473
.iter()
474+
.filter(|package| !immediate_dependencies.contains(*package))
379475
.map(|package| Package {
380476
run: self.run.clone(),
381477
name: package.as_package_name().clone(),

‎turborepo-tests/integration/tests/command-query.t

+22-5
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ Query packages with equals filter
3737
}
3838
3939
Query packages that have at least one dependent package
40-
$ ${TURBO} query "query { packages(filter: { greaterThan: { field: DEPENDENT_COUNT, value: 0 } }) { name } }" | jq
40+
$ ${TURBO} query "query { packages(filter: { greaterThan: { field: DIRECT_DEPENDENT_COUNT, value: 0 } }) { name } }" | jq
4141
WARNING query command is experimental and may change in the future
4242
{
4343
"data": {
@@ -50,13 +50,13 @@ Query packages that have at least one dependent package
5050
}
5151
5252
Get dependents of `util`
53-
$ ${TURBO} query "query { packages(filter: { equal: { field: NAME, value: \"util\" } }) { dependents { name } } }" | jq
53+
$ ${TURBO} query "query { packages(filter: { equal: { field: NAME, value: \"util\" } }) { directDependents { name } } }" | jq
5454
WARNING query command is experimental and may change in the future
5555
{
5656
"data": {
5757
"packages": [
5858
{
59-
"dependents": [
59+
"directDependents": [
6060
{
6161
"name": "my-app"
6262
}
@@ -67,13 +67,13 @@ Get dependents of `util`
6767
}
6868
6969
Get dependencies of `my-app`
70-
$ ${TURBO} query "query { packages(filter: { equal: { field: NAME, value: \"my-app\" } }) { dependencies { name } } }" | jq
70+
$ ${TURBO} query "query { packages(filter: { equal: { field: NAME, value: \"my-app\" } }) { directDependencies { name } } }" | jq
7171
WARNING query command is experimental and may change in the future
7272
{
7373
"data": {
7474
"packages": [
7575
{
76-
"dependencies": [
76+
"directDependencies": [
7777
{
7878
"name": "util"
7979
}
@@ -91,6 +91,23 @@ Get the indirect dependencies of `my-app`
9191
"packages": [
9292
{
9393
"indirectDependencies": [
94+
{
95+
"name": "//"
96+
}
97+
]
98+
}
99+
]
100+
}
101+
}
102+
103+
Get all dependencies of `my-app`
104+
$ ${TURBO} query "query { packages(filter: { equal: { field: NAME, value: \"my-app\" } }) { allDependencies { name } } }" | jq
105+
WARNING query command is experimental and may change in the future
106+
{
107+
"data": {
108+
"packages": [
109+
{
110+
"allDependencies": [
94111
{
95112
"name": "//"
96113
},

0 commit comments

Comments
 (0)