pesde/src/source/wally/manifest.rs

use std::collections::BTreeMap;

use crate::{
	manifest::{errors, DependencyType},
	names::wally::WallyPackageName,
	source::{specifiers::DependencySpecifiers, wally::specifier::WallyDependencySpecifier},
};
use semver::{Version, VersionReq};
use serde::{Deserialize, Deserializer};
use tracing::instrument;

#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "lowercase")]
pub enum Realm {
	#[serde(alias = "dev")]
	Shared,
	Server,
}

#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "kebab-case")]
pub struct WallyPackage {
	pub name: WallyPackageName,
	pub version: Version,
	pub registry: url::Url,
	pub realm: Realm,
}

pub fn deserialize_specifiers<'de, D: Deserializer<'de>>(
	deserializer: D,
) -> Result<BTreeMap<String, WallyDependencySpecifier>, D::Error> {
	// specifier is in form of `name@version_req`
	BTreeMap::<String, String>::deserialize(deserializer)?
		.into_iter()
		.map(|(k, v)| {
			let (name, version) = v.split_once('@').ok_or_else(|| {
				serde::de::Error::custom("invalid specifier format, expected `name@version_req`")
			})?;

			Ok((
				k,
				WallyDependencySpecifier {
					name: name.parse().map_err(serde::de::Error::custom)?,
					version: VersionReq::parse(version).map_err(serde::de::Error::custom)?,
					index: None,
				},
			))
		})
		.collect()
}

#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "kebab-case")]
pub struct WallyManifest {
	pub package: WallyPackage,
	#[serde(default, deserialize_with = "deserialize_specifiers")]
	pub dependencies: BTreeMap<String, WallyDependencySpecifier>,
	#[serde(default, deserialize_with = "deserialize_specifiers")]
	pub server_dependencies: BTreeMap<String, WallyDependencySpecifier>,
	#[serde(default, deserialize_with = "deserialize_specifiers")]
	pub dev_dependencies: BTreeMap<String, WallyDependencySpecifier>,
}

impl WallyManifest {
	/// Get all dependencies from the manifest
	#[instrument(skip(self), ret(level = "trace"), level = "debug")]
	pub fn all_dependencies(
		&self,
	) -> Result<
		BTreeMap<String, (DependencySpecifiers, DependencyType)>,
		errors::AllDependenciesError,
	> {
		let mut all_deps = BTreeMap::new();

		for (deps, ty) in [
			(&self.dependencies, DependencyType::Standard),
			(&self.server_dependencies, DependencyType::Standard),
			(&self.dev_dependencies, DependencyType::Dev),
		] {
			for (alias, spec) in deps {
				let mut spec = spec.clone();
				spec.index = Some(self.package.registry.to_string());

				if all_deps
					.insert(alias.clone(), (DependencySpecifiers::Wally(spec), ty))
					.is_some()
				{
					return Err(errors::AllDependenciesError::AliasConflict(alias.clone()));
				}
			}
		}

		Ok(all_deps)
	}
}