| use std::{ |
| env::current_dir, |
| mem::forget, |
| path::{MAIN_SEPARATOR, PathBuf}, |
| sync::Arc, |
| }; |
|
|
| use anyhow::{Context, Result, bail}; |
| use rustc_hash::FxHashSet; |
| use tracing::Instrument; |
| use turbo_rcstr::RcStr; |
| use turbo_tasks::{ |
| ReadConsistency, ResolvedVc, TransientInstance, TryJoinIterExt, TurboTasks, Vc, apply_effects, |
| }; |
| use turbo_tasks_backend::{ |
| BackendOptions, NoopBackingStorage, TurboTasksBackend, noop_backing_storage, |
| }; |
| use turbo_tasks_fs::FileSystem; |
| use turbopack::{ |
| css::chunk::CssChunkType, ecmascript::chunk::EcmascriptChunkType, |
| global_module_ids::get_global_module_id_strategy, |
| }; |
| use turbopack_browser::{BrowserChunkingContext, ContentHashing, CurrentChunkMethod}; |
| use turbopack_cli_utils::issue::{ConsoleUi, LogOptions}; |
| use turbopack_core::{ |
| asset::Asset, |
| chunk::{ |
| ChunkingConfig, ChunkingContext, EvaluatableAsset, EvaluatableAssets, MangleType, |
| MinifyType, SourceMapsType, availability_info::AvailabilityInfo, |
| }, |
| environment::{BrowserEnvironment, Environment, ExecutionEnvironment, NodeJsEnvironment}, |
| ident::AssetIdent, |
| issue::{IssueReporter, IssueSeverity, handle_issues}, |
| module::Module, |
| module_graph::{ |
| ModuleGraph, |
| chunk_group_info::{ChunkGroup, ChunkGroupEntry}, |
| export_usage::compute_export_usage_info, |
| }, |
| output::{OutputAsset, OutputAssets}, |
| reference::all_assets_from_entries, |
| reference_type::{EntryReferenceSubType, ReferenceType}, |
| resolve::{ |
| origin::{PlainResolveOrigin, ResolveOriginExt}, |
| parse::Request, |
| }, |
| }; |
| use turbopack_ecmascript_runtime::RuntimeType; |
| use turbopack_env::dotenv::load_env; |
| use turbopack_node::execution_context::ExecutionContext; |
| use turbopack_nodejs::NodeJsChunkingContext; |
|
|
| use crate::{ |
| arguments::{BuildArguments, Target}, |
| contexts::{NodeEnv, get_client_asset_context, get_client_compile_time_info}, |
| util::{ |
| EntryRequest, NormalizedDirs, normalize_dirs, normalize_entries, output_fs, project_fs, |
| }, |
| }; |
|
|
| type Backend = TurboTasksBackend<NoopBackingStorage>; |
|
|
| pub struct TurbopackBuildBuilder { |
| turbo_tasks: Arc<TurboTasks<Backend>>, |
| project_dir: RcStr, |
| root_dir: RcStr, |
| entry_requests: Vec<EntryRequest>, |
| browserslist_query: RcStr, |
| log_level: IssueSeverity, |
| show_all: bool, |
| log_detail: bool, |
| source_maps_type: SourceMapsType, |
| minify_type: MinifyType, |
| target: Target, |
| scope_hoist: bool, |
| } |
|
|
| impl TurbopackBuildBuilder { |
| pub fn new(turbo_tasks: Arc<TurboTasks<Backend>>, project_dir: RcStr, root_dir: RcStr) -> Self { |
| TurbopackBuildBuilder { |
| turbo_tasks, |
| project_dir, |
| root_dir, |
| entry_requests: vec![], |
| browserslist_query: "last 1 Chrome versions, last 1 Firefox versions, last 1 Safari \ |
| versions, last 1 Edge versions" |
| .into(), |
| log_level: IssueSeverity::Warning, |
| show_all: false, |
| log_detail: false, |
| source_maps_type: SourceMapsType::Full, |
| minify_type: MinifyType::Minify { |
| mangle: Some(MangleType::OptimalSize), |
| }, |
| target: Target::Node, |
| scope_hoist: true, |
| } |
| } |
|
|
| pub fn entry_request(mut self, entry_asset_path: EntryRequest) -> Self { |
| self.entry_requests.push(entry_asset_path); |
| self |
| } |
|
|
| pub fn browserslist_query(mut self, browserslist_query: RcStr) -> Self { |
| self.browserslist_query = browserslist_query; |
| self |
| } |
|
|
| pub fn log_level(mut self, log_level: IssueSeverity) -> Self { |
| self.log_level = log_level; |
| self |
| } |
|
|
| pub fn show_all(mut self, show_all: bool) -> Self { |
| self.show_all = show_all; |
| self |
| } |
|
|
| pub fn log_detail(mut self, log_detail: bool) -> Self { |
| self.log_detail = log_detail; |
| self |
| } |
|
|
| pub fn source_maps_type(mut self, source_maps_type: SourceMapsType) -> Self { |
| self.source_maps_type = source_maps_type; |
| self |
| } |
|
|
| pub fn minify_type(mut self, minify_type: MinifyType) -> Self { |
| self.minify_type = minify_type; |
| self |
| } |
|
|
| pub fn scope_hoist(mut self, scope_hoist: bool) -> Self { |
| self.scope_hoist = scope_hoist; |
| self |
| } |
|
|
| pub fn target(mut self, target: Target) -> Self { |
| self.target = target; |
| self |
| } |
|
|
| pub async fn build(self) -> Result<()> { |
| let task = self.turbo_tasks.spawn_once_task::<(), _>(async move { |
| let build_result_op = build_internal( |
| self.project_dir.clone(), |
| self.root_dir, |
| self.entry_requests.clone(), |
| self.browserslist_query, |
| self.source_maps_type, |
| self.minify_type, |
| self.target, |
| self.scope_hoist, |
| ); |
|
|
| |
| build_result_op.read_strongly_consistent().await?; |
|
|
| apply_effects(build_result_op) |
| .instrument(tracing::info_span!("apply effects")) |
| .await?; |
|
|
| let issue_reporter: Vc<Box<dyn IssueReporter>> = |
| Vc::upcast(ConsoleUi::new(TransientInstance::new(LogOptions { |
| project_dir: PathBuf::from(self.project_dir), |
| current_dir: current_dir().unwrap(), |
| show_all: self.show_all, |
| log_detail: self.log_detail, |
| log_level: self.log_level, |
| }))); |
|
|
| handle_issues( |
| build_result_op, |
| issue_reporter, |
| IssueSeverity::Error, |
| None, |
| None, |
| ) |
| .await?; |
|
|
| Ok(Default::default()) |
| }); |
|
|
| self.turbo_tasks |
| .wait_task_completion(task, ReadConsistency::Strong) |
| .await?; |
|
|
| Ok(()) |
| } |
| } |
|
|
| #[turbo_tasks::function(operation)] |
| async fn build_internal( |
| project_dir: RcStr, |
| root_dir: RcStr, |
| entry_requests: Vec<EntryRequest>, |
| browserslist_query: RcStr, |
| source_maps_type: SourceMapsType, |
| minify_type: MinifyType, |
| target: Target, |
| scope_hoist: bool, |
| ) -> Result<Vc<()>> { |
| let output_fs = output_fs(project_dir.clone()); |
| let project_fs = project_fs(root_dir.clone(), false); |
| let project_relative = project_dir.strip_prefix(&*root_dir).unwrap(); |
| let project_relative: RcStr = project_relative |
| .strip_prefix(MAIN_SEPARATOR) |
| .unwrap_or(project_relative) |
| .replace(MAIN_SEPARATOR, "/") |
| .into(); |
| let root_path = project_fs.root().owned().await?; |
| let project_path = root_path.join(&project_relative)?; |
| let build_output_root = output_fs.root().await?.join("dist")?; |
|
|
| let node_env = NodeEnv::Production.cell(); |
|
|
| let build_output_root_to_root_path = project_path |
| .join("dist")? |
| .get_relative_path_to(&root_path) |
| .context("Project path is in root path")?; |
|
|
| let runtime_type = match *node_env.await? { |
| NodeEnv::Development => RuntimeType::Development, |
| NodeEnv::Production => RuntimeType::Production, |
| }; |
|
|
| let compile_time_info = get_client_compile_time_info(browserslist_query.clone(), node_env); |
| let execution_context = ExecutionContext::new( |
| root_path.clone(), |
| Vc::upcast( |
| NodeJsChunkingContext::builder( |
| project_path.clone(), |
| build_output_root.clone(), |
| build_output_root_to_root_path.clone(), |
| build_output_root.clone(), |
| build_output_root.clone(), |
| build_output_root.clone(), |
| Environment::new(ExecutionEnvironment::NodeJsLambda( |
| NodeJsEnvironment::default().resolved_cell(), |
| )) |
| .to_resolved() |
| .await?, |
| runtime_type, |
| ) |
| .build(), |
| ), |
| load_env(root_path.clone()), |
| ); |
|
|
| let asset_context = get_client_asset_context( |
| project_path.clone(), |
| execution_context, |
| compile_time_info, |
| node_env, |
| source_maps_type, |
| ); |
|
|
| let entry_requests = (*entry_requests |
| .into_iter() |
| .map(|r| async move { |
| Ok(match r { |
| EntryRequest::Relative(p) => Request::relative( |
| p.clone().into(), |
| Default::default(), |
| Default::default(), |
| false, |
| ), |
| EntryRequest::Module(m, p) => Request::module( |
| m.clone(), |
| p.clone().into(), |
| Default::default(), |
| Default::default(), |
| ), |
| }) |
| }) |
| .try_join() |
| .await?) |
| .to_vec(); |
|
|
| let origin = PlainResolveOrigin::new(asset_context, project_fs.root().await?.join("_")?); |
| let project_dir = &project_dir; |
| let entries = async move { |
| entry_requests |
| .into_iter() |
| .map(|request_vc| async move { |
| let ty = ReferenceType::Entry(EntryReferenceSubType::Undefined); |
| let request = request_vc.await?; |
| origin |
| .resolve_asset(request_vc, origin.resolve_options(ty.clone()).await?, ty) |
| .await? |
| .first_module() |
| .await? |
| .with_context(|| { |
| format!( |
| "Unable to resolve entry {} from directory {}.", |
| request.request().unwrap(), |
| project_dir |
| ) |
| }) |
| }) |
| .try_join() |
| .await |
| } |
| .instrument(tracing::info_span!("resolve entries")) |
| .await?; |
|
|
| let module_graph = ModuleGraph::from_modules( |
| Vc::cell(vec![ChunkGroupEntry::Entry(entries.clone())]), |
| false, |
| ); |
| let module_id_strategy = ResolvedVc::upcast( |
| get_global_module_id_strategy(module_graph) |
| .to_resolved() |
| .await?, |
| ); |
| let export_usage = compute_export_usage_info(module_graph.to_resolved().await?) |
| .resolve_strongly_consistent() |
| .await?; |
|
|
| let chunking_context: Vc<Box<dyn ChunkingContext>> = match target { |
| Target::Browser => { |
| let mut builder = BrowserChunkingContext::builder( |
| project_path, |
| build_output_root.clone(), |
| build_output_root_to_root_path, |
| build_output_root.clone(), |
| build_output_root.clone(), |
| build_output_root.clone(), |
| Environment::new(ExecutionEnvironment::Browser( |
| BrowserEnvironment { |
| dom: true, |
| web_worker: false, |
| service_worker: false, |
| browserslist_query: browserslist_query.clone(), |
| } |
| .resolved_cell(), |
| )) |
| .to_resolved() |
| .await?, |
| runtime_type, |
| ) |
| .source_maps(source_maps_type) |
| .module_id_strategy(module_id_strategy) |
| .export_usage(Some(export_usage)) |
| .current_chunk_method(CurrentChunkMethod::DocumentCurrentScript) |
| .minify_type(minify_type); |
|
|
| match *node_env.await? { |
| NodeEnv::Development => {} |
| NodeEnv::Production => { |
| builder = builder |
| .chunking_config( |
| Vc::<EcmascriptChunkType>::default().to_resolved().await?, |
| ChunkingConfig { |
| min_chunk_size: 50_000, |
| max_chunk_count_per_group: 40, |
| max_merge_chunk_size: 200_000, |
| ..Default::default() |
| }, |
| ) |
| .chunking_config( |
| Vc::<CssChunkType>::default().to_resolved().await?, |
| ChunkingConfig { |
| max_merge_chunk_size: 100_000, |
| ..Default::default() |
| }, |
| ) |
| .use_content_hashing(ContentHashing::Direct { length: 16 }) |
| .module_merging(scope_hoist); |
| } |
| } |
|
|
| Vc::upcast(builder.build()) |
| } |
| Target::Node => { |
| let mut builder = NodeJsChunkingContext::builder( |
| project_path, |
| build_output_root.clone(), |
| build_output_root_to_root_path, |
| build_output_root.clone(), |
| build_output_root.clone(), |
| build_output_root.clone(), |
| Environment::new(ExecutionEnvironment::NodeJsLambda( |
| NodeJsEnvironment::default().resolved_cell(), |
| )) |
| .to_resolved() |
| .await?, |
| runtime_type, |
| ) |
| .source_maps(source_maps_type) |
| .module_id_strategy(module_id_strategy) |
| .export_usage(Some(export_usage)) |
| .minify_type(minify_type); |
|
|
| match *node_env.await? { |
| NodeEnv::Development => {} |
| NodeEnv::Production => { |
| builder = builder |
| .chunking_config( |
| Vc::<EcmascriptChunkType>::default().to_resolved().await?, |
| ChunkingConfig { |
| min_chunk_size: 20_000, |
| max_chunk_count_per_group: 100, |
| max_merge_chunk_size: 100_000, |
| ..Default::default() |
| }, |
| ) |
| .chunking_config( |
| Vc::<CssChunkType>::default().to_resolved().await?, |
| ChunkingConfig { |
| max_merge_chunk_size: 100_000, |
| ..Default::default() |
| }, |
| ) |
| .module_merging(scope_hoist); |
| } |
| } |
|
|
| Vc::upcast(builder.build()) |
| } |
| }; |
|
|
| let entry_chunk_groups = entries |
| .into_iter() |
| .map(|entry_module| { |
| let build_output_root = build_output_root.clone(); |
|
|
| async move { |
| Ok( |
| if let Some(ecmascript) = |
| ResolvedVc::try_sidecast::<Box<dyn EvaluatableAsset>>(entry_module) |
| { |
| match target { |
| Target::Browser => { |
| chunking_context |
| .evaluated_chunk_group( |
| AssetIdent::from_path( |
| build_output_root |
| .join( |
| ecmascript |
| .ident() |
| .path() |
| .await? |
| .file_stem() |
| .unwrap(), |
| )? |
| .with_extension("entry.js"), |
| ), |
| ChunkGroup::Entry( |
| [ResolvedVc::upcast(ecmascript)].into_iter().collect(), |
| ), |
| module_graph, |
| AvailabilityInfo::Root, |
| ) |
| .await? |
| .assets |
| } |
| Target::Node => ResolvedVc::cell(vec![ |
| chunking_context |
| .entry_chunk_group( |
| build_output_root |
| .join( |
| ecmascript |
| .ident() |
| .path() |
| .await? |
| .file_stem() |
| .unwrap(), |
| )? |
| .with_extension("entry.js"), |
| EvaluatableAssets::one(*ResolvedVc::upcast(ecmascript)), |
| module_graph, |
| OutputAssets::empty(), |
| AvailabilityInfo::Root, |
| ) |
| .await? |
| .asset, |
| ]), |
| } |
| } else { |
| bail!( |
| "Entry module is not chunkable, so it can't be used to bootstrap the \ |
| application" |
| ) |
| }, |
| ) |
| } |
| }) |
| .try_join() |
| .await?; |
|
|
| let mut chunks: FxHashSet<ResolvedVc<Box<dyn OutputAsset>>> = FxHashSet::default(); |
| for chunk_group in entry_chunk_groups { |
| chunks.extend( |
| &*async move { all_assets_from_entries(*chunk_group).await } |
| .instrument(tracing::info_span!("list chunks")) |
| .await?, |
| ); |
| } |
|
|
| chunks |
| .iter() |
| .map(|c| async move { c.content().write(c.path().owned().await?).await }) |
| .try_join() |
| .await?; |
|
|
| Ok(Default::default()) |
| } |
|
|
| pub async fn build(args: &BuildArguments) -> Result<()> { |
| let NormalizedDirs { |
| project_dir, |
| root_dir, |
| } = normalize_dirs(&args.common.dir, &args.common.root)?; |
|
|
| let tt = TurboTasks::new(TurboTasksBackend::new( |
| BackendOptions { |
| dependency_tracking: false, |
| storage_mode: None, |
| ..Default::default() |
| }, |
| noop_backing_storage(), |
| )); |
|
|
| let mut builder = TurbopackBuildBuilder::new(tt.clone(), project_dir, root_dir) |
| .log_detail(args.common.log_detail) |
| .log_level( |
| args.common |
| .log_level |
| .map_or_else(|| IssueSeverity::Warning, |l| l.0), |
| ) |
| .source_maps_type(if args.no_sourcemap { |
| SourceMapsType::None |
| } else { |
| SourceMapsType::Full |
| }) |
| .minify_type(if args.no_minify { |
| MinifyType::NoMinify |
| } else { |
| MinifyType::Minify { |
| mangle: Some(MangleType::OptimalSize), |
| } |
| }) |
| .scope_hoist(!args.no_scope_hoist) |
| .target(args.common.target.unwrap_or(Target::Node)) |
| .show_all(args.common.show_all); |
|
|
| for entry in normalize_entries(&args.common.entries) { |
| builder = builder.entry_request(EntryRequest::Relative(entry)); |
| } |
|
|
| builder.build().await?; |
|
|
| |
| |
| if !args.force_memory_cleanup { |
| forget(tt); |
| } |
|
|
| Ok(()) |
| } |
|
|
