feat: support pass closure to restriction (#604)

Co-authored-by: Cong-Cong Pan <[email protected]>

Author: JounQin

Cargo.lock

@@ -97,6 +97,7 @@ document-features = { version = "0.2.11", optional = true }
 [dev-dependencies]
 criterion2 = { version = "3.0.1", default-features = false }
 dirs = { version = "6.0.0" }
+fancy-regex = { version = "^0.14.0", default-features = false, features = ["std"] }
 normalize-path = { version = "0.2.1" }
 pico-args = "0.5.0"
 rayon = { version = "1.10.0" }

Cargo.toml

@@ -22,6 +22,7 @@ doctest = false
 [dependencies]
 oxc_resolver = { workspace = true }
 
+fancy-regex = { version = "^0.14.0", default-features = false, features = ["std"] }
 napi = { version = "3.0.0-beta.12", default-features = false, features = ["napi3", "serde-json"] }
 napi-derive = { version = "3.0.0-beta.12" }
 tracing-subscriber = { version = "0.3.19", optional = true, default-features = false, features = ["std", "fmt"] } # Omit the `regex` feature

napi/Cargo.toml

@@ -1,5 +1,6 @@
-use std::{collections::HashMap, path::PathBuf};
+use std::{collections::HashMap, path::PathBuf, sync::Arc};
 
+use fancy_regex::Regex;
 use napi::Either;
 use napi_derive::napi;
 
@@ -219,7 +220,12 @@ impl From<Restriction> for oxc_resolver::Restriction {
             (None, None) => {
                 panic!("Should specify path or regex")
             }
-            (None, Some(regex)) => oxc_resolver::Restriction::RegExp(regex),
+            (None, Some(regex)) => {
+                let re = Regex::new(&regex).unwrap();
+                oxc_resolver::Restriction::Fn(Arc::new(move |path| {
+                    re.is_match(path.to_str().unwrap_or_default()).unwrap_or(false)
+                }))
+            }
             (Some(path), None) => oxc_resolver::Restriction::Path(PathBuf::from(path)),
             (Some(_), Some(_)) => {
                 panic!("Restriction can't be path and regex at the same time")

napi/src/options.rs

@@ -82,10 +82,6 @@ pub enum ResolveError {
     #[error("{0:?}")]
     Json(JSONError),
 
-    /// Restricted by `ResolveOptions::restrictions`
-    #[error(r#"Path "{0}" restricted by {0}"#)]
-    Restriction(PathBuf, PathBuf),
-
     #[error(r#"Invalid module "{0}" specifier is not a valid subpath for the "exports" resolution of {1}"#)]
     InvalidModuleSpecifier(String, PathBuf),
 

src/error.rs

@@ -278,8 +278,6 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
             cached_path.to_path_buf()
         };
 
-        // enhanced-resolve: restrictions
-        self.check_restrictions(&path)?;
         let package_json = self.find_package_json_for_a_package(&cached_path, ctx)?;
         if let Some(package_json) = &package_json {
             // path must be inside the package.
@@ -753,7 +751,7 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
         }
     }
 
-    fn check_restrictions(&self, path: &Path) -> Result<(), ResolveError> {
+    fn check_restrictions(&self, path: &Path) -> bool {
         // https://github.com/webpack/enhanced-resolve/blob/a998c7d218b7a9ec2461fc4fddd1ad5dd7687485/lib/RestrictionsPlugin.js#L19-L24
         fn is_inside(path: &Path, parent: &Path) -> bool {
             if !path.starts_with(parent) {
@@ -768,26 +766,27 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
             match restriction {
                 Restriction::Path(restricted_path) => {
                     if !is_inside(path, restricted_path) {
-                        return Err(ResolveError::Restriction(
-                            path.to_path_buf(),
-                            restricted_path.clone(),
-                        ));
+                        return false;
                     }
                 }
-                Restriction::RegExp(_) => {
-                    return Err(ResolveError::Unimplemented("Restriction with regex"));
+                Restriction::Fn(f) => {
+                    if !f(path) {
+                        return false;
+                    }
                 }
             }
         }
-        Ok(())
+        true
     }
 
     fn load_index(&self, cached_path: &CachedPath, ctx: &mut Ctx) -> ResolveResult {
         for main_file in &self.options.main_files {
             let cached_path = cached_path.normalize_with(main_file, self.cache.as_ref());
             if self.options.enforce_extension.is_disabled() {
                 if let Some(path) = self.load_alias_or_file(&cached_path, ctx)? {
-                    return Ok(Some(path));
+                    if self.check_restrictions(path.path()) {
+                        return Ok(Some(path));
+                    }
                 }
             }
             // 1. If X/index.js is a file, load X/index.js as JavaScript text. STOP
@@ -833,7 +832,7 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
         if let Some(path) = self.load_browser_field_or_alias(cached_path, ctx)? {
             return Ok(Some(path));
         }
-        if self.cache.is_file(cached_path, ctx) {
+        if self.cache.is_file(cached_path, ctx) && self.check_restrictions(cached_path.path()) {
             return Ok(Some(cached_path.clone()));
         }
         Ok(None)
@@ -1150,7 +1149,11 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
             // Complete when resolving to self `{"./a.js": "./a.js"}`
             if new_specifier.strip_prefix("./").filter(|s| path.ends_with(Path::new(s))).is_some() {
                 return if self.cache.is_file(cached_path, ctx) {
-                    Ok(Some(cached_path.clone()))
+                    if self.check_restrictions(cached_path.path()) {
+                        Ok(Some(cached_path.clone()))
+                    } else {
+                        Ok(None)
+                    }
                 } else {
                     Err(ResolveError::NotFound(new_specifier.to_string()))
                 };
@@ -1323,6 +1326,8 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
         if !self.cache.is_file(cached_path, ctx) {
             ctx.with_fully_specified(false);
             return Ok(None);
+        } else if !self.check_restrictions(cached_path.path()) {
+            return Ok(None);
         }
         // Create a meaningful error message.
         let dir = path.parent().unwrap().to_path_buf();
@@ -1559,7 +1564,9 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
                                 // 1. Return the URL resolution of main in packageURL.
                                 let cached_path =
                                     cached_path.normalize_with(main_field, self.cache.as_ref());
-                                if self.cache.is_file(&cached_path, ctx) {
+                                if self.cache.is_file(&cached_path, ctx)
+                                    && self.check_restrictions(cached_path.path())
+                                {
                                     return Ok(Some(cached_path));
                                 }
                             }

src/lib.rs

@@ -1,6 +1,7 @@
 use std::{
     fmt,
     path::{Path, PathBuf},
+    sync::Arc,
 };
 
 /// Module Resolution Options
@@ -456,10 +457,19 @@ where
 }
 
 /// Value for [ResolveOptions::restrictions]
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub enum Restriction {
     Path(PathBuf),
-    RegExp(String),
+    Fn(Arc<dyn Fn(&Path) -> bool + Sync + Send>),
+}
+
+impl std::fmt::Debug for Restriction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Path(path) => write!(f, "Path(\"{}\")", path.display()),
+            Self::Fn(_) => write!(f, "Fn(<function>)"),
+        }
+    }
 }
 
 /// Tsconfig Options for [ResolveOptions::tsconfig]

src/options.rs

@@ -1,16 +1,48 @@
 //! <https://github.com/webpack/enhanced-resolve/blob/main/test/restrictions.test.js>
 
+use std::sync::Arc;
+
+use fancy_regex::Regex;
+
 use crate::{ResolveError, ResolveOptions, Resolver, Restriction};
 
-// TODO: regex
-// * should respect RegExp restriction
-// * should try to find alternative #1
-// * should try to find alternative #2
-// * should try to find alternative #3
+#[test]
+fn should_respect_regexp_restriction() {
+    let f = super::fixture().join("restrictions");
+
+    let re = Regex::new(r"\.(sass|scss|css)$").unwrap();
+    let resolver1 = Resolver::new(ResolveOptions {
+        extensions: vec![".js".into()],
+        restrictions: vec![Restriction::Fn(Arc::new(move |path| {
+            path.as_os_str().to_str().is_some_and(|s| re.is_match(s).unwrap_or(false))
+        }))],
+        ..ResolveOptions::default()
+    });
+
+    let resolution = resolver1.resolve(&f, "pck1").map(|r| r.full_path());
+    assert_eq!(resolution, Err(ResolveError::NotFound("pck1".to_string())));
+}
+
+#[test]
+fn should_try_to_find_alternative_1() {
+    let f = super::fixture().join("restrictions");
+
+    let re = Regex::new(r"\.(sass|scss|css)$").unwrap();
+    let resolver1 = Resolver::new(ResolveOptions {
+        extensions: vec![".js".into(), ".css".into()],
+        main_files: vec!["index".into()],
+        restrictions: vec![Restriction::Fn(Arc::new(move |path| {
+            path.as_os_str().to_str().is_some_and(|s| re.is_match(s).unwrap_or(false))
+        }))],
+        ..ResolveOptions::default()
+    });
+
+    let resolution = resolver1.resolve(&f, "pck1").map(|r| r.full_path());
+    assert_eq!(resolution, Ok(f.join("node_modules/pck1/index.css")));
+}
 
-// should respect string restriction
 #[test]
-fn restriction1() {
+fn should_respect_string_restriction() {
     let fixture = super::fixture();
     let f = fixture.join("restrictions");
 
@@ -21,5 +53,41 @@ fn restriction1() {
     });
 
     let resolution = resolver.resolve(&f, "pck2");
-    assert_eq!(resolution, Err(ResolveError::Restriction(fixture.join("c.js"), f)));
+    assert_eq!(resolution, Err(ResolveError::NotFound("pck2".to_string())));
+}
+
+#[test]
+fn should_try_to_find_alternative_2() {
+    let f = super::fixture().join("restrictions");
+
+    let re = Regex::new(r"\.(sass|scss|css)$").unwrap();
+    let resolver1 = Resolver::new(ResolveOptions {
+        extensions: vec![".js".into(), ".css".into()],
+        main_fields: vec!["main".into(), "style".into()],
+        restrictions: vec![Restriction::Fn(Arc::new(move |path| {
+            path.as_os_str().to_str().is_some_and(|s| re.is_match(s).unwrap_or(false))
+        }))],
+        ..ResolveOptions::default()
+    });
+
+    let resolution = resolver1.resolve(&f, "pck2").map(|r| r.full_path());
+    assert_eq!(resolution, Ok(f.join("node_modules/pck2/index.css")));
+}
+
+#[test]
+fn should_try_to_find_alternative_3() {
+    let f = super::fixture().join("restrictions");
+
+    let re = Regex::new(r"\.(sass|scss|css)$").unwrap();
+    let resolver1 = Resolver::new(ResolveOptions {
+        extensions: vec![".js".into()],
+        main_fields: vec!["main".into(), "module".into(), "style".into()],
+        restrictions: vec![Restriction::Fn(Arc::new(move |path| {
+            path.as_os_str().to_str().is_some_and(|s| re.is_match(s).unwrap_or(false))
+        }))],
+        ..ResolveOptions::default()
+    });
+
+    let resolution = resolver1.resolve(&f, "pck2").map(|r| r.full_path());
+    assert_eq!(resolution, Ok(f.join("node_modules/pck2/index.css")));
 }