fix: install dev packages and remove them after use

CHANGELOG.md

@@ -14,6 +14,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Inherit pesde-managed scripts from workspace root by @daimond113
 - Allow using binaries from workspace root in member packages by @daimond113
 
+### Fixed
+- Install dev packages in prod mode and remove them after use to allow them to be used in scripts by @daimond113
+
 ### Changed
 - Change handling of graphs to a flat structure by @daimond113
 - Store dependency over downloaded graphs in the lockfile by @daimond113

src/download_and_link.rs

@@ -189,10 +189,6 @@ impl Project {
 				let container_folder =
 					node.container_folder_from_project(&id, self, manifest.target.kind());
 
-				if prod && node.resolved_ty == DependencyType::Dev {
-					continue;
-				}
-
 				downloaded_graph.insert(id, node);
 
 				let cas_dir = self.cas_dir().to_path_buf();
@@ -308,7 +304,50 @@ impl Project {
 				.map_err(errors::DownloadAndLinkError::Hook)?;
 		}
 
-		Ok(Arc::into_inner(graph).unwrap())
+		let mut graph = Arc::into_inner(graph).unwrap();
+
+		if prod {
+			let (dev_graph, prod_graph) = graph
+				.into_iter()
+				.partition::<DependencyGraphWithTarget, _>(|(_, node)| {
+					node.node.resolved_ty == DependencyType::Dev
+				});
+
+			graph = prod_graph;
+			let dev_graph = Arc::new(dev_graph);
+
+			let manifest_target_kind = manifest.target.kind();
+
+			// the `true` argument means it'll remove the dependencies linkers
+			self.link(
+				&dev_graph,
+				&Arc::new(manifest),
+				&Arc::new(Default::default()),
+				false,
+				true,
+			)
+			.await?;
+
+			let mut tasks = dev_graph
+				.iter()
+				.map(|(id, node)| {
+					let container_folder =
+						node.node
+							.container_folder_from_project(id, self, manifest_target_kind);
+					async move {
+						fs::remove_dir_all(&container_folder)
+							.await
+							.map_err(errors::DownloadAndLinkError::Io)
+					}
+				})
+				.collect::<JoinSet<_>>();
+
+			while let Some(task) = tasks.join_next().await {
+				task.unwrap()?;
+			}
+		}
+
+		Ok(graph)
 	}
 }
 

src/linking/mod.rs

@@ -68,7 +68,13 @@ impl Project {
 
 		// step 1. link all non-wally packages (and their dependencies) temporarily without types
 		// we do this separately to allow the required tools for the scripts to be installed
-		self.link(&graph, &manifest, &Arc::new(PackageTypes::default()), false)
+		self.link(
+			&graph,
+			&manifest,
+			&Arc::new(PackageTypes::default()),
+			false,
+			false,
+		)
 		.await?;
 
 		if !with_types {
@@ -150,7 +156,7 @@ impl Project {
 		}
 
 		// step 3. link all packages (and their dependencies), this time with types
-		self.link(&graph, &manifest, &Arc::new(package_types), true)
+		self.link(&graph, &manifest, &Arc::new(package_types), true, false)
 			.await
 	}
 
@@ -164,12 +170,30 @@ impl Project {
 		node: &DependencyGraphNodeWithTarget,
 		package_id: &PackageId,
 		alias: &str,
-		package_types: &PackageTypes,
+		package_types: &Arc<PackageTypes>,
-		manifest: &Manifest,
+		manifest: &Arc<Manifest>,
+		remove: bool,
+		is_root: bool,
 	) -> Result<(), errors::LinkingError> {
 		static NO_TYPES: Vec<String> = Vec::new();
 
+		#[allow(clippy::result_large_err)]
+		fn into_link_result(res: std::io::Result<()>) -> Result<(), errors::LinkingError> {
+			match res {
+				Ok(_) => Ok(()),
+				Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
+				Err(e) => Err(e.into()),
+			}
+		}
+
+		let mut tasks = JoinSet::<Result<(), errors::LinkingError>>::new();
+
 		if let Some(lib_file) = node.target.lib_path() {
+			let destination = base_folder.join(format!("{alias}.luau"));
+
+			if remove {
+				tasks.spawn(async move { into_link_result(fs::remove_file(destination).await) });
+			} else {
 				let lib_module = generator::generate_lib_linking_module(
 					&generator::get_lib_require_path(
 						node.target.kind(),
@@ -183,60 +207,91 @@ impl Project {
 					)?,
 					package_types.get(package_id).unwrap_or(&NO_TYPES),
 				);
+				let cas_dir = self.cas_dir().to_path_buf();
 
-			write_cas(
+				tasks.spawn(async move {
-				base_folder.join(format!("{alias}.luau")),
+					write_cas(destination, &cas_dir, &lib_module)
-				self.cas_dir(),
+						.await
-				&lib_module,
+						.map_err(Into::into)
-			)
+				});
-			.await?;
+			}
 		}
 
 		if let Some(bin_file) = node.target.bin_path() {
+			let destination = base_folder.join(format!("{alias}.bin.luau"));
+
+			if remove {
+				tasks.spawn(async move { into_link_result(fs::remove_file(destination).await) });
+			} else {
 				let bin_module = generator::generate_bin_linking_module(
 					container_folder,
 					&generator::get_bin_require_path(base_folder, bin_file, container_folder),
 				);
+				let cas_dir = self.cas_dir().to_path_buf();
 
-			write_cas(
+				tasks.spawn(async move {
-				base_folder.join(format!("{alias}.bin.luau")),
+					write_cas(destination, &cas_dir, &bin_module)
-				self.cas_dir(),
+						.await
-				&bin_module,
+						.map_err(Into::into)
-			)
+				});
-			.await?;
+			}
 		}
 
-		if let Some(scripts) = node.target.scripts().filter(|s| !s.is_empty()) {
+		if let Some(scripts) = node
-			let scripts_base =
+			.target
-				create_and_canonicalize(self.package_dir().join(SCRIPTS_LINK_FOLDER).join(alias))
+			.scripts()
-					.await?;
+			.filter(|s| !s.is_empty() && node.node.direct.is_some() && is_root)
+		{
+			let scripts_container = self.package_dir().join(SCRIPTS_LINK_FOLDER);
+			let scripts_base = create_and_canonicalize(scripts_container.join(alias)).await?;
 
+			if remove {
+				tasks.spawn(async move {
+					fs::remove_dir_all(scripts_base).await?;
+					if let Ok(mut entries) = fs::read_dir(&scripts_container).await {
+						if entries.next_entry().await.transpose().is_none() {
+							drop(entries);
+							fs::remove_dir(&scripts_container).await?;
+						}
+					}
+
+					Ok(())
+				});
+			} else {
 				for (script_name, script_path) in scripts {
-				let script_module =
+					let destination = scripts_base.join(format!("{script_name}.luau"));
-					generator::generate_script_linking_module(&generator::get_script_require_path(
+					let script_module = generator::generate_script_linking_module(
+						&generator::get_script_require_path(
 							&scripts_base,
 							script_path,
 							container_folder,
-					));
+						),
+					);
+					let cas_dir = self.cas_dir().to_path_buf();
 
-				write_cas(
+					tasks.spawn(async move {
-					scripts_base.join(format!("{script_name}.luau")),
+						write_cas(destination, &cas_dir, &script_module)
-					self.cas_dir(),
+							.await
-					&script_module,
+							.map_err(Into::into)
-				)
+					});
-				.await?;
 				}
 			}
+		}
+
+		while let Some(task) = tasks.join_next().await {
+			task.unwrap()?;
+		}
 
 		Ok(())
 	}
 
-	async fn link(
+	pub(crate) async fn link(
 		&self,
 		graph: &Arc<DependencyGraphWithTarget>,
 		manifest: &Arc<Manifest>,
 		package_types: &Arc<PackageTypes>,
 		is_complete: bool,
+		remove: bool,
 	) -> Result<(), errors::LinkingError> {
 		let mut tasks = graph
 			.iter()
@@ -278,6 +333,8 @@ impl Project {
 									alias,
 									&package_types,
 									&manifest,
+									remove,
+									true,
 								)
 								.await?;
 						}
@@ -330,6 +387,8 @@ impl Project {
 								dependency_alias,
 								&package_types,
 								&manifest,
+								remove,
+								false,
 							)
 							.await?;
 					}