Handle cloudflare: scheeme and no longer rewrite node: scheme

devongovett · devongovett · commit ccd4d462f278 · 2025-03-30T09:26:28.000-07:00
diff --git a/crates/parcel-resolver/src/lib.rs b/crates/parcel-resolver/src/lib.rs
@@ -181,7 +181,7 @@ pub enum Resolution {
   /// Resolved to a file path.
   Path(PathBuf),
   /// Resolved to a runtime builtin module.
-  Builtin(String),
+  Builtin { scheme: String, module: String },
   /// Resolved to an external module that should not be bundled.
   External,
   /// Resolved to an empty module (e.g. `false` in the package.json#browser field).
@@ -623,11 +623,14 @@ impl<'a> ResolveRequest<'a> {
         // Bare specifier.
         self.resolve_bare(module, subpath)
       }
-      Specifier::Builtin(builtin) => {
+      Specifier::Builtin(scheme, module) => {
         if let Some(res) = self.resolve_package_aliases_and_tsconfig_paths(self.specifier)? {
           return Ok(res);
         }
-        Ok(Resolution::Builtin(builtin.as_ref().to_owned()))
+        Ok(Resolution::Builtin {
+          scheme: scheme.as_ref().to_owned(),
+          module: module.as_ref().to_owned(),
+        })
       }
       Specifier::Url(url) => {
         if self.specifier_type == SpecifierType::Url {
@@ -2521,15 +2524,21 @@ mod tests {
         .result
         .unwrap()
         .resolution,
-      Resolution::Builtin("zlib".into())
+      Resolution::Builtin {
+        scheme: "".into(),
+        module: "zlib".into()
+      }
     );
     assert_eq!(
       test_resolver()
         .resolve("node:zlib", &root().join("foo.js"), SpecifierType::Esm)
         .result
         .unwrap()
         .resolution,
-      Resolution::Builtin("zlib".into())
+      Resolution::Builtin {
+        scheme: "node".into(),
+        module: "zlib".into()
+      }
     );
     assert_eq!(
       test_resolver()
@@ -2541,7 +2550,10 @@ mod tests {
         .result
         .unwrap()
         .resolution,
-      Resolution::Builtin("fs/promises".into())
+      Resolution::Builtin {
+        scheme: "node".into(),
+        module: "fs/promises".into()
+      }
     );
     assert_eq!(
       test_resolver()
@@ -2553,7 +2565,25 @@ mod tests {
         .result
         .unwrap()
         .resolution,
-      Resolution::Builtin("@std/http/file-server".into())
+      Resolution::Builtin {
+        scheme: "jsr".into(),
+        module: "@std/http/file-server".into()
+      }
+    );
+    assert_eq!(
+      test_resolver()
+        .resolve(
+          "cloudflare:workers",
+          &root().join("foo.js"),
+          SpecifierType::Esm
+        )
+        .result
+        .unwrap()
+        .resolution,
+      Resolution::Builtin {
+        scheme: "cloudflare".into(),
+        module: "workers".into()
+      }
     );
   }
 
@@ -2675,7 +2705,10 @@ mod tests {
         .result
         .unwrap()
         .resolution,
-      Resolution::Builtin("zlib".into())
+      Resolution::Builtin {
+        scheme: "".into(),
+        module: "zlib".into()
+      }
     );
 
     let invalidations = test_resolver()
diff --git a/crates/parcel-resolver/src/specifier.rs b/crates/parcel-resolver/src/specifier.rs
@@ -63,7 +63,7 @@ pub enum Specifier<'a> {
   /// A package specifier and subpath, e.g. 'lodash/clone'.
   Package(Cow<'a, str>, Cow<'a, str>),
   /// A Node builtin module, e.g. 'path' or 'node:path'.
-  Builtin(Cow<'a, str>),
+  Builtin(Cow<'a, str>, Cow<'a, str>),
   /// A URL specifier.
   Url(&'a str),
 }
@@ -118,7 +118,10 @@ impl<'a> Specifier<'a> {
               match scheme.as_ref() {
                 "npm" if flags.contains(Flags::NPM_SCHEME) => {
                   if BUILTINS.contains(&path) {
-                    return Ok((Specifier::Builtin(Cow::Borrowed(path)), None));
+                    return Ok((
+                      Specifier::Builtin(Cow::Borrowed(""), Cow::Borrowed(path)),
+                      None,
+                    ));
                   }
 
                   (
@@ -127,10 +130,11 @@ impl<'a> Specifier<'a> {
                   )
                 }
                 // Treat Deno's "jsr:" dependencies as builtins so they get marked as external.
-                "node" | "jsr" => {
+                // Also Cloudflare schemes: https://github.com/cloudflare/workerd/blob/b7bcb543812dfd9fdc0d9b391801ec1bc4f0973a/src/workerd/jsg/commonjs.c%2B%2B#L27
+                "node" | "jsr" | "cloudflare" | "workerd" => {
                   // Node does not URL decode or support query params here.
                   // See https://github.com/nodejs/node/issues/39710.
-                  (Specifier::Builtin(Cow::Borrowed(path)), None)
+                  (Specifier::Builtin(scheme, Cow::Borrowed(path)), None)
                 }
                 "file" => (
                   Specifier::Absolute(Cow::Owned(url_to_path(specifier)?)),
@@ -144,7 +148,10 @@ impl<'a> Specifier<'a> {
               let (path, rest) = parse_path(specifier);
               if specifier_type == SpecifierType::Esm {
                 if BUILTINS.contains(&path) {
-                  return Ok((Specifier::Builtin(Cow::Borrowed(path)), None));
+                  return Ok((
+                    Specifier::Builtin(Cow::Borrowed(""), Cow::Borrowed(path)),
+                    None,
+                  ));
                 }
 
                 let (query, _) = parse_query(rest);
@@ -159,12 +166,20 @@ impl<'a> Specifier<'a> {
             }
           }
           SpecifierType::Cjs => {
-            if let Some(node_prefixed) = specifier.strip_prefix("node:") {
-              return Ok((Specifier::Builtin(Cow::Borrowed(node_prefixed)), None));
+            if let Some((scheme, module)) = specifier.split_once(':') {
+              if matches!(scheme, "node" | "jsr" | "cloudflare" | "workerd") {
+                return Ok((
+                  Specifier::Builtin(Cow::Borrowed(scheme), Cow::Borrowed(module)),
+                  None,
+                ));
+              }
             }
 
             if BUILTINS.contains(&specifier) {
-              (Specifier::Builtin(Cow::Borrowed(specifier)), None)
+              (
+                Specifier::Builtin(Cow::Borrowed(""), Cow::Borrowed(specifier)),
+                None,
+              )
             } else {
               #[cfg(windows)]
               if !flags.contains(Flags::ABSOLUTE_SPECIFIERS) {
@@ -200,7 +215,16 @@ impl<'a> Specifier<'a> {
           Cow::Owned(res)
         }
       }
-      Specifier::Builtin(builtin) => Cow::Borrowed(builtin),
+      Specifier::Builtin(scheme, builtin) => {
+        if scheme.is_empty() {
+          return Cow::Borrowed(builtin);
+        }
+        let mut res = String::with_capacity(scheme.len() + builtin.len() + 1);
+        res.push_str(scheme);
+        res.push(':');
+        res.push_str(builtin);
+        Cow::Owned(res)
+      }
       Specifier::Url(url) => Cow::Borrowed(url),
     }
   }
@@ -350,7 +374,10 @@ impl<'de> serde::Deserialize<'de> for Specifier<'static> {
         Specifier::Package(a, b) => {
           Specifier::Package(Cow::Owned(a.into_owned()), Cow::Owned(b.into_owned()))
         }
-        Specifier::Builtin(a) => Specifier::Builtin(Cow::Owned(a.into_owned())),
+        Specifier::Builtin(scheme, module) => Specifier::Builtin(
+          Cow::Owned(scheme.into_owned()),
+          Cow::Owned(module.into_owned()),
+        ),
         Specifier::Url(_) => todo!(),
       })
       .map_err(|_| serde::de::Error::custom("Invalid specifier"))
diff --git a/packages/core/package-manager/src/NodePackageManager.js b/packages/core/package-manager/src/NodePackageManager.js
@@ -23,7 +23,6 @@ import Module from 'module';
 import path from 'path';
 import semver from 'semver';
 import logger from '@parcel/logger';
-import nullthrows from 'nullthrows';
 
 import {getModuleParts} from '@parcel/utils';
 import {getConflictingLocalDependencies} from './utils';
@@ -621,30 +620,36 @@ export class NodePackageManager implements PackageManager {
       e.code = 'MODULE_NOT_FOUND';
       throw e;
     }
-    let getPkg;
     switch (res.resolution.type) {
-      case 'Path':
-        getPkg = () => {
-          let pkgPath = this.fs.findAncestorFile(
-            ['package.json'],
-            nullthrows(res.resolution.value),
-            this.projectRoot,
-          );
-          return pkgPath
-            ? JSON.parse(this.fs.readFileSync(pkgPath, 'utf8'))
-            : null;
-        };
-      // fallthrough
-      case 'Builtin':
+      case 'Path': {
+        let self = this;
+        let resolved = res.resolution.value;
         return {
-          resolved: res.resolution.value,
+          resolved,
           invalidateOnFileChange: new Set(res.invalidateOnFileChange),
           invalidateOnFileCreate: res.invalidateOnFileCreate,
           type: res.moduleType,
           get pkg() {
-            return getPkg();
+            let pkgPath = self.fs.findAncestorFile(
+              ['package.json'],
+              resolved,
+              self.projectRoot,
+            );
+            return pkgPath
+              ? JSON.parse(self.fs.readFileSync(pkgPath, 'utf8'))
+              : null;
           },
         };
+      }
+      case 'Builtin': {
+        let {scheme, module} = res.resolution.value;
+        return {
+          resolved: scheme ? `${scheme}:${module}` : module,
+          invalidateOnFileChange: new Set(res.invalidateOnFileChange),
+          invalidateOnFileCreate: res.invalidateOnFileCreate,
+          type: res.moduleType,
+        };
+      }
       default:
         throw new Error('Unknown resolution type');
     }
diff --git a/packages/core/rust/index.js.flow b/packages/core/rust/index.js.flow
@@ -40,7 +40,7 @@ export interface ResolveOptions {
 }
 export type Resolution =
   | {|type: 'Path', value: string|}
-  | {|type: 'Builtin', value: string|}
+  | {|type: 'Builtin', value: {|scheme: string, module: string|}|}
   | {|type: 'External'|}
   | {|type: 'Empty'|}
   | {|type: 'Global', value: string|};
diff --git a/packages/dev/repl/src/parcel/BrowserPackageManager.js b/packages/dev/repl/src/parcel/BrowserPackageManager.js
@@ -202,31 +202,38 @@ export class BrowserPackageManager implements PackageManager {
         e.code = 'MODULE_NOT_FOUND';
         throw e;
       }
-      let getPkg;
       switch (res.resolution.type) {
-        case 'Path':
-          getPkg = () => {
-            let pkgPath = this.fs.findAncestorFile(
-              ['package.json'],
-              nullthrows(res.resolution.value),
-              this.projectRoot,
-            );
-            resolved = pkgPath
-              ? JSON.parse(this.fs.readFileSync(pkgPath, 'utf8'))
-              : null;
-          };
-        // fallthrough
-        case 'Builtin':
+        case 'Path': {
+          let self = this;
+          let resolution = res.resolution.value;
           resolved = {
-            resolved: res.resolution.value,
+            resolved: resolution,
             invalidateOnFileChange: new Set(res.invalidateOnFileChange),
             invalidateOnFileCreate: res.invalidateOnFileCreate,
             type: res.moduleType,
             get pkg() {
-              return getPkg();
+              let pkgPath = self.fs.findAncestorFile(
+                ['package.json'],
+                resolution,
+                self.projectRoot,
+              );
+              return pkgPath
+                ? JSON.parse(self.fs.readFileSync(pkgPath, 'utf8'))
+                : null;
             },
           };
           break;
+        }
+        case 'Builtin': {
+          let {scheme, module} = res.resolution.value;
+          resolved = {
+            resolved: scheme ? `${scheme}:${module}` : module,
+            invalidateOnFileChange: new Set(res.invalidateOnFileChange),
+            invalidateOnFileCreate: res.invalidateOnFileCreate,
+            type: res.moduleType,
+          };
+          break;
+        }
         default:
           throw new Error('Unknown resolution type');
       }
diff --git a/packages/packagers/react-static/src/ReactStaticPackager.js b/packages/packagers/react-static/src/ReactStaticPackager.js
@@ -439,12 +439,14 @@ async function loadBundleUncached(
     }
 
     let defaultRequire = Module.createRequire(from);
-    if (res.resolution.type === 'Builtin') {
-      return defaultRequire(res.resolution.value);
+    let resolution = res.resolution;
+    if (resolution.type === 'Builtin') {
+      let {scheme, module} = resolution.value;
+      return defaultRequire(scheme ? `${scheme}:${module}` : module);
     }
 
-    if (res.resolution.type === 'Path') {
-      let cacheKey = res.resolution.value + '#' + env;
+    if (resolution.type === 'Path') {
+      let cacheKey = resolution.value + '#' + env;
       const cachedModule = moduleCache.get(cacheKey);
       if (cachedModule) {
         return cachedModule.exports;
@@ -455,7 +457,7 @@ async function loadBundleUncached(
         return loadAsset(assetId);
       }
 
-      let filePath = nullthrows(res.resolution.value);
+      let filePath = resolution.value;
       let code = fs.readFileSync(filePath, 'utf8');
       let require = (id: string) => {
         return loadModule(id, filePath, env);
diff --git a/packages/transformers/js/core/src/dependency_collector.rs b/packages/transformers/js/core/src/dependency_collector.rs
@@ -347,18 +347,6 @@ impl<'a> DependencyCollector<'a> {
   }
 }
 
-fn rewrite_require_specifier(node: ast::CallExpr, unresolved_mark: Mark) -> ast::CallExpr {
-  if let Some(arg) = node.args.first() {
-    if let Some((value, _)) = match_str(&arg.expr) {
-      if value.starts_with("node:") {
-        // create_require will take care of replacing the node: prefix...
-        return create_require(value, unresolved_mark);
-      }
-    }
-  }
-  node
-}
-
 impl<'a> Fold for DependencyCollector<'a> {
   fn fold_module(&mut self, node: ast::Module) -> ast::Module {
     let mut res = node.fold_children_with(self);
@@ -889,12 +877,11 @@ impl<'a> Fold for DependencyCollector<'a> {
       call.args.truncate(1);
 
       // Track the returned require call to be replaced with a promise chain.
-      let rewritten_call = rewrite_require_specifier(call, self.unresolved_mark);
-      self.require_node = Some(rewritten_call.clone());
-      rewritten_call
+      self.require_node = Some(call.clone());
+      call
     } else if kind == DependencyKind::Require {
       // Don't continue traversing so that the `require` isn't replaced with undefined
-      rewrite_require_specifier(node, self.unresolved_mark)
+      node
     } else {
       node.fold_children_with(self)
     }
diff --git a/packages/transformers/js/core/src/utils.rs b/packages/transformers/js/core/src/utils.rs
diff --git a/packages/utils/node-resolver-core/src/Wrapper.js b/packages/utils/node-resolver-core/src/Wrapper.js

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ export interface ResolveOptions {`
`40`	`40`	`}`
`41`	`41`	`export type Resolution =`
`42`	`42`	`\| {\|type: 'Path', value: string\|}`
`43`		`- \| {\|type: 'Builtin', value: string\|}`
	`43`	`+ \| {\|type: 'Builtin', value: {\|scheme: string, module: string\|}\|}`
`44`	`44`	`\| {\|type: 'External'\|}`
`45`	`45`	`\| {\|type: 'Empty'\|}`
`46`	`46`	`\| {\|type: 'Global', value: string\|};`