feat(config): exit 1 when a dependency type is not found

Closes #234

Author: JamieMason

src/context.rs

@@ -31,27 +31,34 @@ pub struct Context {
 impl Context {
   pub fn create(config: Config, packages: Packages) -> Self {
     let mut instances = vec![];
+    let all_dependency_types = config.rcfile.get_all_dependency_types();
     let dependency_groups = config.rcfile.get_dependency_groups(&packages);
     let semver_groups = config.rcfile.get_semver_groups(&packages);
     let mut version_groups = config.rcfile.get_version_groups(&packages);
     let local_versions = packages.get_local_versions();
 
-    packages.get_all_instances(&config, |mut descriptor| {
-      let dependency_group = dependency_groups.iter().find(|alias| alias.can_add(&descriptor));
+    packages.get_all_instances(&all_dependency_types, |mut descriptor| {
+      let dependency_group = dependency_groups
+        .iter()
+        .find(|alias| alias.can_add(&all_dependency_types, &descriptor));
 
       if let Some(group) = dependency_group {
         descriptor.internal_name = group.label.clone();
       }
 
       match &config.cli.filter {
         Some(cli_group) => {
-          descriptor.matches_cli_filter = cli_group.can_add(&descriptor);
+          descriptor.matches_cli_filter = cli_group.can_add(&all_dependency_types, &descriptor);
         }
         None => descriptor.matches_cli_filter = true,
       }
 
-      let semver_group = semver_groups.iter().find(|group| group.selector.can_add(&descriptor));
-      let version_group = version_groups.iter_mut().find(|group| group.selector.can_add(&descriptor));
+      let semver_group = semver_groups
+        .iter()
+        .find(|group| group.selector.can_add(&all_dependency_types, &descriptor));
+      let version_group = version_groups
+        .iter_mut()
+        .find(|group| group.selector.can_add(&all_dependency_types, &descriptor));
       let instance = Rc::new(Instance::new(descriptor));
 
       instances.push(Rc::clone(&instance));

src/group_selector.rs

@@ -1,6 +1,8 @@
 use {
-  crate::{instance::InstanceDescriptor, packages::Packages},
+  crate::{dependency_type::DependencyType, instance::InstanceDescriptor, packages::Packages},
   globset::{Glob, GlobMatcher},
+  log::error,
+  std::process,
 };
 
 #[derive(Clone, Debug)]
@@ -70,30 +72,46 @@ impl GroupSelector {
     }
   }
 
-  pub fn can_add(&self, descriptor: &InstanceDescriptor) -> bool {
-    self.matches_dependency_types(descriptor)
+  pub fn can_add(&self, all_dependency_types: &[DependencyType], descriptor: &InstanceDescriptor) -> bool {
+    self.has_valid_dependency_types(all_dependency_types)
+      && self.matches_dependency_types(descriptor)
       && self.matches_packages(descriptor)
       && self.matches_dependencies(descriptor)
       && self.matches_specifier_types(descriptor)
   }
 
-  pub fn matches_dependency_types(&self, descriptor: &InstanceDescriptor) -> bool {
+  fn has_valid_dependency_types(&self, all_dependency_types: &[DependencyType]) -> bool {
+    self
+      .include_dependency_types
+      .iter()
+      .chain(self.exclude_dependency_types.iter())
+      .for_each(|expected| {
+        if !all_dependency_types.iter().any(|actual| actual.name == *expected) {
+          error!("dependencyType '{expected}' does not match any of syncpack or your customTypes");
+          error!("check your syncpack config file");
+          process::exit(1);
+        }
+      });
+    true
+  }
+
+  fn matches_dependency_types(&self, descriptor: &InstanceDescriptor) -> bool {
     matches_identifiers(
       &descriptor.dependency_type.name,
       &self.include_dependency_types,
       &self.exclude_dependency_types,
     )
   }
 
-  pub fn matches_packages(&self, descriptor: &InstanceDescriptor) -> bool {
+  fn matches_packages(&self, descriptor: &InstanceDescriptor) -> bool {
     matches_globs(&descriptor.package.borrow().name, &self.include_packages, &self.exclude_packages)
   }
 
-  pub fn matches_dependencies(&self, descriptor: &InstanceDescriptor) -> bool {
+  fn matches_dependencies(&self, descriptor: &InstanceDescriptor) -> bool {
     matches_globs(&descriptor.internal_name, &self.include_dependencies, &self.exclude_dependencies)
   }
 
-  pub fn matches_specifier_types(&self, descriptor: &InstanceDescriptor) -> bool {
+  fn matches_specifier_types(&self, descriptor: &InstanceDescriptor) -> bool {
     self.include_specifier_types.is_empty()
       || matches_identifiers(
         &descriptor.specifier.get_config_identifier(),

src/packages.rs

@@ -2,7 +2,7 @@ use {
   crate::{
     cli::Cli,
     config::Config,
-    dependency_type::Strategy,
+    dependency_type::{DependencyType, Strategy},
     instance::InstanceDescriptor,
     package_json::PackageJson,
     rcfile::Rcfile,
@@ -73,13 +73,13 @@ impl Packages {
   }
 
   /// Get every instance of a dependency from every package.json file
-  pub fn get_all_instances<F>(&self, config: &Config, mut on_instance: F)
+  pub fn get_all_instances<F>(&self, all_dependency_types: &Vec<DependencyType>, mut on_instance: F)
   where
     F: FnMut(InstanceDescriptor),
   {
     let local_versions = self.get_local_versions();
     for package in self.all.iter() {
-      for dependency_type in &config.rcfile.get_all_dependency_types() {
+      for dependency_type in all_dependency_types {
         match dependency_type.strategy {
           Strategy::NameAndVersionProps => {
             if let (Some(Value::String(name)), Some(Value::String(raw_specifier))) = (