chore: Fix graph resolver, npm modules, cache settings

Author: andreespirela

Cargo.lock

@@ -1,10 +1,12 @@
 import { primordials, core } from "ext:core/mod.js";
 const { SymbolAsyncIterator } = primordials;
 
+const { op_event_accept } = core.ensureFastOps()
+
 class SupabaseEventListener {
 	async nextEvent() {
 		try {
-			const reqEvt = await core.opAsync('op_event_accept');
+			const reqEvt = await op_event_accept();
 			const done = reqEvt === 'Done';
 
 			let value = undefined;

crates/event_worker/event_worker.js

@@ -34,6 +34,7 @@ impl NpmCacheDir {
 
         // this may fail on readonly file systems, so just ignore if so
         let root_dir = try_get_canonicalized_root_dir(&root_dir).unwrap_or(root_dir);
+        println!("Cache Dir {}", root_dir.clone().to_str().unwrap());
         let root_dir_url = Url::from_directory_path(&root_dir).unwrap();
         Self {
             root_dir,

crates/npm/cache_dir.rs

@@ -21,6 +21,7 @@ use deno_core::url::Url;
 use deno_npm::registry::NpmPackageInfo;
 use deno_npm::registry::NpmRegistryApi;
 use deno_npm::registry::NpmRegistryPackageInfoLoadError;
+use once_cell::sync::Lazy;
 
 use sb_core::cache::CacheSetting;
 use sb_core::cache::CACHE_PERM;
@@ -30,10 +31,32 @@ use sb_core::util::sync::AtomicFlag;
 
 use super::cache::NpmCache;
 
+static NPM_REGISTRY_DEFAULT_URL: Lazy<Url> = Lazy::new(|| {
+    let env_var_name = "NPM_CONFIG_REGISTRY";
+    if let Ok(registry_url) = std::env::var(env_var_name) {
+        // ensure there is a trailing slash for the directory
+        let registry_url = format!("{}/", registry_url.trim_end_matches('/'));
+        match Url::parse(&registry_url) {
+            Ok(url) => {
+                return url;
+            }
+            Err(err) => {
+                println!("Invalid {} environment variable: {:#}", env_var_name, err,);
+            }
+        }
+    }
+
+    Url::parse("https://registry.npmjs.org").unwrap()
+});
+
 #[derive(Debug)]
 pub struct CliNpmRegistryApi(Option<Arc<CliNpmRegistryApiInner>>);
 
 impl CliNpmRegistryApi {
+    pub fn default_url() -> &'static Url {
+        &NPM_REGISTRY_DEFAULT_URL
+    }
+
     pub fn new(base_url: Url, cache: Arc<NpmCache>, http_client: Arc<HttpClient>) -> Self {
         Self(Some(Arc::new(CliNpmRegistryApiInner {
             base_url,

crates/npm/managed/registry.rs

@@ -216,16 +216,16 @@ function runtimeStart(runtimeOptions, source) {
 // This is because v8 sets a console that can't be easily overriden
 // and collides with globalScope.console
 delete globalThis.console;
-// ObjectDefineProperties(globalThis, globalScope);
+ObjectDefineProperties(globalThis, globalScope);
 
 const globalProperties = {
-	// Window: globalInterfaces.windowConstructorDescriptor,
-	// window: getterOnly(() => globalThis),
-	// Navigator: nonEnumerable(Navigator),
-	// navigator: getterOnly(() => navigator),
-	// self: getterOnly(() => globalThis),
+	Window: globalInterfaces.windowConstructorDescriptor,
+	window: getterOnly(() => globalThis),
+	Navigator: nonEnumerable(Navigator),
+	navigator: getterOnly(() => navigator),
+	self: getterOnly(() => globalThis),
 };
-// ObjectDefineProperties(globalThis, globalProperties);
+ObjectDefineProperties(globalThis, globalProperties);
 
 const deleteDenoApis = (apis) => {
 	apis.forEach((key) => {

crates/sb_core/js/bootstrap.js

@@ -265,15 +265,15 @@ impl EmitterFactory {
                     maybe_lockfile: self.get_lock_file(),
                     fs: self.real_fs(),
                     http_client: self.http_client(),
-                    npm_global_cache_dir: Default::default(),
-                    cache_setting: CacheSetting::Only,
+                    npm_global_cache_dir: self.deno_dir.npm_folder_path().clone(),
+                    cache_setting: CacheSetting::Use,
                     maybe_node_modules_path: None,
                     npm_system_info: Default::default(),
                     package_json_installer:
                         CliNpmResolverManagedPackageJsonInstallerOption::ConditionalInstall(
                             self.package_json_deps_provider().clone(),
                         ),
-                    npm_registry_url: ModuleSpecifier::parse("https://localhost/").unwrap(),
+                    npm_registry_url: CliNpmRegistryApi::default_url().clone(),
                 })
                 .await
             })
@@ -318,6 +318,7 @@ impl EmitterFactory {
                     self.package_json_deps_provider().clone(),
                     self.package_json_deps_installer().await.clone(),
                     self.cli_graph_resolver_options(),
+                    Some(self.npm_resolver().await.clone()),
                 )))
             })
             .await

crates/sb_graph/emitter.rs

@@ -146,6 +146,7 @@ impl CliGraphResolver {
         package_json_deps_provider: Arc<PackageJsonDepsProvider>,
         package_json_deps_installer: Arc<PackageJsonDepsInstaller>,
         options: CliGraphResolverOptions,
+        npm_resolver: Option<Arc<dyn CliNpmResolver>>,
     ) -> Self {
         Self {
             mapped_specifier_resolver: MappedSpecifierResolver {
@@ -167,7 +168,7 @@ impl CliGraphResolver {
             npm_resolution,
             package_json_deps_installer,
             found_package_json_dep_flag: Default::default(),
-            npm_resolver: None,
+            npm_resolver,
         }
     }
 

crates/sb_graph/graph_resolver.rs

@@ -128,7 +128,7 @@ pub async fn create_module_loader_for_eszip(
         fs: fs.clone(),
         http_client,
         npm_global_cache_dir,
-        cache_setting: CacheSetting::Only,
+        cache_setting: CacheSetting::Use,
         maybe_node_modules_path: None,
         npm_system_info: Default::default(),
         package_json_installer: CliNpmResolverManagedPackageJsonInstallerOption::ConditionalInstall(

crates/sb_module_loader/standalone/mod.rs

@@ -7,6 +7,11 @@ import { readableStreamForRid, writableStreamForRid } from 'ext:deno_web/06_stre
 import { getWatcherRid } from 'ext:sb_core_main_js/js/http.js';
 const ops = core.ops;
 
+const {
+	op_user_worker_fetch_send,
+	op_user_worker_create
+} = core.ensureFastOps();
+
 // interface WorkerOptions {
 //     servicePath: string;
 //     memoryLimitMb?: number;
@@ -70,7 +75,7 @@ Invoke \`EdgeRuntime.applyConnectionWatcher(origReq, newReq)\` if you have clone
 			reqBodyPromise = body.pipeTo(writableStream, { signal });
 		}
 
-		const resPromise = core.opAsync('op_user_worker_fetch_send', this.key, requestRid, watcherRid);
+		const resPromise = op_user_worker_fetch_send(this.key, requestRid, watcherRid);
 		let [sent, res] = await Promise.allSettled([reqBodyPromise, resPromise]);
 
 		if (sent.status === "rejected") {
@@ -142,7 +147,7 @@ Invoke \`EdgeRuntime.applyConnectionWatcher(origReq, newReq)\` if you have clone
 			throw new TypeError('service path must be defined');
 		}
 
-		const key = await core.opAsync('op_user_worker_create', readyOptions);
+		const key = await op_user_worker_create(readyOptions);
 
 		return new UserWorker(key);
 	}