Use package boundaries rules to restrict package's dependencies and dependents

Author: NicholasLYang

crates/turborepo-lib/src/boundaries/mod.rs

@@ -67,6 +67,13 @@ pub enum SecondaryDiagnostic {
 
 #[derive(Clone, Debug, Error, Diagnostic)]
 pub enum BoundariesDiagnostic {
+    #[error("Package boundaries rules cannot have `tags` key")]
+    PackageBoundariesHasTags {
+        #[label("tags defined here")]
+        span: Option<SourceSpan>,
+        #[source_code]
+        text: NamedSource<String>,
+    },
     #[error("Tag `{tag}` cannot share the same name as package `{package}`")]
     TagSharesPackageName {
         tag: String,

crates/turborepo-lib/src/boundaries/tags.rs

@@ -177,6 +177,53 @@ impl Run {
         Ok(None)
     }
 
+    pub(crate) fn check_tag(
+        &self,
+        diagnostics: &mut Vec<BoundariesDiagnostic>,
+        dependencies: Option<&ProcessedPermissions>,
+        dependents: Option<&ProcessedPermissions>,
+        pkg: &PackageNode,
+        package_json: &PackageJson,
+    ) -> Result<(), Error> {
+        if let Some(dependency_permissions) = dependencies {
+            for dependency in self.pkg_dep_graph().dependencies(&pkg) {
+                if matches!(dependency, PackageNode::Root) {
+                    continue;
+                }
+
+                let dependency_tags = self.load_package_tags(dependency.as_package_name());
+
+                diagnostics.extend(self.validate_relation(
+                    pkg.as_package_name(),
+                    package_json,
+                    dependency.as_package_name(),
+                    dependency_tags,
+                    dependency_permissions.allow.as_ref(),
+                    dependency_permissions.deny.as_ref(),
+                )?);
+            }
+        }
+
+        if let Some(dependent_permissions) = dependents {
+            for dependent in self.pkg_dep_graph().ancestors(&pkg) {
+                if matches!(dependent, PackageNode::Root) {
+                    continue;
+                }
+                let dependent_tags = self.load_package_tags(dependent.as_package_name());
+                diagnostics.extend(self.validate_relation(
+                    pkg.as_package_name(),
+                    package_json,
+                    dependent.as_package_name(),
+                    dependent_tags,
+                    dependent_permissions.allow.as_ref(),
+                    dependent_permissions.deny.as_ref(),
+                )?)
+            }
+        }
+
+        Ok(())
+    }
+
     pub(crate) fn check_package_tags(
         &self,
         pkg: PackageNode,
@@ -185,6 +232,34 @@ impl Run {
         tags_rules: &ProcessedRulesMap,
     ) -> Result<Vec<BoundariesDiagnostic>, Error> {
         let mut diagnostics = Vec::new();
+        let package_boundaries = self
+            .turbo_json_loader()
+            .load(pkg.as_package_name())
+            .ok()
+            .and_then(|turbo_json| turbo_json.boundaries.as_ref());
+
+        if let Some(boundaries) = package_boundaries {
+            if let Some(tags) = &boundaries.tags {
+                let (span, text) = tags.span_and_text("turbo.json");
+                diagnostics.push(BoundariesDiagnostic::PackageBoundariesHasTags { span, text });
+            }
+            let dependencies = boundaries
+                .dependencies
+                .clone()
+                .map(|deps| deps.into_inner().into());
+            let dependents = boundaries
+                .dependents
+                .clone()
+                .map(|deps| deps.into_inner().into());
+
+            self.check_tag(
+                &mut diagnostics,
+                dependencies.as_ref(),
+                dependents.as_ref(),
+                &pkg,
+                package_json,
+            )?;
+        }
 
         // We don't allow tags to share the same name as the package because
         // we allow package names to be used as a tag
@@ -210,41 +285,13 @@ impl Run {
 
         for tag in current_package_tags.iter() {
             if let Some(rule) = tags_rules.get(tag.as_inner()) {
-                if let Some(dependency_permissions) = &rule.dependencies {
-                    for dependency in self.pkg_dep_graph().dependencies(&pkg) {
-                        if matches!(dependency, PackageNode::Root) {
-                            continue;
-                        }
-
-                        let dependency_tags = self.load_package_tags(dependency.as_package_name());
-
-                        diagnostics.extend(self.validate_relation(
-                            pkg.as_package_name(),
-                            package_json,
-                            dependency.as_package_name(),
-                            dependency_tags,
-                            dependency_permissions.allow.as_ref(),
-                            dependency_permissions.deny.as_ref(),
-                        )?);
-                    }
-                }
-
-                if let Some(dependent_permissions) = &rule.dependents {
-                    for dependent in self.pkg_dep_graph().ancestors(&pkg) {
-                        if matches!(dependent, PackageNode::Root) {
-                            continue;
-                        }
-                        let dependent_tags = self.load_package_tags(dependent.as_package_name());
-                        diagnostics.extend(self.validate_relation(
-                            pkg.as_package_name(),
-                            package_json,
-                            dependent.as_package_name(),
-                            dependent_tags,
-                            dependent_permissions.allow.as_ref(),
-                            dependent_permissions.deny.as_ref(),
-                        )?)
-                    }
-                }
+                self.check_tag(
+                    &mut diagnostics,
+                    rule.dependencies.as_ref(),
+                    rule.dependents.as_ref(),
+                    &pkg,
+                    package_json,
+                )?;
             }
         }
 

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

@@ -100,6 +100,14 @@ impl From<BoundariesDiagnostic> for Diagnostic {
                 import: None,
                 reason: Some(tag),
             },
+            BoundariesDiagnostic::PackageBoundariesHasTags { span, text: _ } => Diagnostic {
+                message,
+                path: None,
+                start: span.map(|span| span.offset()),
+                end: span.map(|span| span.offset() + span.len()),
+                import: None,
+                reason: None,
+            },
         }
     }
 }