fix(turbopack): Allow google font fetch errors to propagate when in production

joshhannaford/pack-4667-google-font-fetch-should-fail-in-production-for-turbopack

Author: Cy-Tek

crates/next-core/src/next_font/google/mod.rs

@@ -18,6 +18,7 @@ use turbo_tasks_hash::hash_xxh3_hash64;
 use turbopack::evaluate_context::node_evaluate_asset_context;
 use turbopack_core::{
     asset::AssetContent,
+    chunk::ChunkingContext,
     context::AssetContext,
     ident::AssetIdent,
     issue::{IssueExt, IssueSeverity},
@@ -218,6 +219,7 @@ impl NextFontGoogleCssModuleReplacer {
         // requests to Google Fonts.
         let env = Vc::upcast::<Box<dyn ProcessEnv>>(CommandLineProcessEnv::new());
         let mocked_responses_path = &*env.read("NEXT_FONT_GOOGLE_MOCKED_RESPONSES".into()).await?;
+
         let stylesheet_str = mocked_responses_path
             .as_ref()
             .map_or_else(
@@ -227,6 +229,7 @@ impl NextFontGoogleCssModuleReplacer {
             .await?;
 
         let font_fallback = get_font_fallback(*self.project_path, options);
+        let is_dev_mode = self.execution_context.chunking_context().is_dev_mode();
 
         let stylesheet = match stylesheet_str {
             Some(s) => Some(
@@ -239,13 +242,21 @@ impl NextFontGoogleCssModuleReplacer {
                 .owned()
                 .await?,
             ),
-            None => {
+            // Inform the user of the failure to retreive the stylesheet / font, but don't
+            // propagate this error. We don't want e.g. offline connections to prevent page
+            // renders during development. During production builds, however, this error
+            // should propagate.
+            None if *is_dev_mode.await? => {
                 println!(
                     "Failed to download `{}` from Google Fonts. Using fallback font instead.",
                     options.await?.font_family
                 );
                 None
             }
+            None => bail!(
+                "Failed to fetch `{}` from Google Fonts.",
+                options.await?.font_family
+            ),
         };
 
         let css_asset = VirtualSource::new(
@@ -312,13 +323,20 @@ struct NextFontGoogleFontFileOptions {
 #[turbo_tasks::value(shared)]
 pub struct NextFontGoogleFontFileReplacer {
     project_path: ResolvedVc<FileSystemPath>,
+    execution_context: ResolvedVc<ExecutionContext>,
 }
 
 #[turbo_tasks::value_impl]
 impl NextFontGoogleFontFileReplacer {
     #[turbo_tasks::function]
-    pub fn new(project_path: ResolvedVc<FileSystemPath>) -> Vc<Self> {
-        Self::cell(NextFontGoogleFontFileReplacer { project_path })
+    pub fn new(
+        project_path: ResolvedVc<FileSystemPath>,
+        execution_context: ResolvedVc<ExecutionContext>,
+    ) -> Vc<Self> {
+        Self::cell(NextFontGoogleFontFileReplacer {
+            project_path,
+            execution_context,
+        })
     }
 }
 
@@ -616,16 +634,9 @@ async fn fetch_from_google_fonts(
     )
     .await?;
 
-    Ok(match &*result {
+    Ok(match *result {
         Ok(r) => Some(*r.await?.body),
         Err(err) => {
-            // Inform the user of the failure to retreive the stylesheet / font, but don't
-            // propagate this error. We don't want e.g. offline connections to prevent page
-            // renders during development. During production builds, however, this error
-            // should propagate.
-            //
-            // TODO(WEB-283): Use fallback in dev in this case
-            // TODO(WEB-293): Fail production builds (not dev) in this case
             err.to_issue(IssueSeverity::Warning.into(), virtual_path)
                 .to_resolved()
                 .await?

crates/next-core/src/next_import_map.rs

@@ -902,7 +902,7 @@ async fn insert_next_shared_aliases(
     import_map.insert_alias(
         AliasPattern::exact(GOOGLE_FONTS_INTERNAL_PREFIX),
         ImportMapping::Dynamic(ResolvedVc::upcast(
-            NextFontGoogleFontFileReplacer::new(*project_path)
+            NextFontGoogleFontFileReplacer::new(*project_path, execution_context)
                 .to_resolved()
                 .await?,
         ))

turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -705,4 +705,11 @@ impl ChunkingContext for BrowserChunkingContext {
             self.chunk_item_id_from_ident(AsyncLoaderModule::asset_ident_for(module))
         })
     }
+
+    #[turbo_tasks::function]
+    async fn is_dev_mode(self: Vc<Self>) -> Result<Vc<bool>> {
+        Ok(Vc::cell(
+            self.await?.runtime_type == RuntimeType::Development,
+        ))
+    }
 }

turbopack/crates/turbopack-core/src/chunk/chunking_context.rs

@@ -249,6 +249,8 @@ pub trait ChunkingContext {
     fn chunk_item_id_from_module(self: Vc<Self>, module: Vc<Box<dyn Module>>) -> Vc<ModuleId> {
         self.chunk_item_id_from_ident(module.ident())
     }
+
+    fn is_dev_mode(self: Vc<Self>) -> Result<Vc<bool>>;
 }
 
 pub trait ChunkingContextExt {

turbopack/crates/turbopack-nodejs/src/chunking_context.rs

@@ -494,4 +494,11 @@ impl ChunkingContext for NodeJsChunkingContext {
             self.chunk_item_id_from_ident(AsyncLoaderModule::asset_ident_for(module))
         })
     }
+
+    #[turbo_tasks::function]
+    async fn is_dev_mode(self: Vc<Self>) -> Result<Vc<bool>> {
+        Ok(Vc::cell(
+            self.await?.runtime_type == RuntimeType::Development,
+        ))
+    }
 }