refactor: make specifier index not an option

Instead, we use the `default` serde attribute
to deserialize the index as `DEFAULT_INDEX_NAME`
if it is not present. This removes a lot of
redundancy around the codebase about getting
the index name.

registry/src/endpoints/publish_version.rs

@@ -289,32 +289,26 @@ pub async fn publish_package(
 
 			match specifier {
 				DependencySpecifiers::Pesde(specifier) => {
-					if specifier
-						.index
-						.as_deref()
-						.filter(|index| match gix::Url::try_from(*index) {
-							Ok(url) => config
-								.other_registries_allowed
-								.is_allowed_or_same(source.repo_url().clone(), url),
-							Err(_) => false,
-						})
-						.is_none()
-					{
+					let allowed = match gix::Url::try_from(&*specifier.index) {
+						Ok(url) => config
+							.other_registries_allowed
+							.is_allowed_or_same(source.repo_url().clone(), url),
+						Err(_) => false,
+					};
+
+					if !allowed {
 						return Err(RegistryError::InvalidArchive(format!(
 							"invalid index in pesde dependency {specifier}"
 						)));
 					}
 				}
 				DependencySpecifiers::Wally(specifier) => {
-					if specifier
-						.index
-						.as_deref()
-						.filter(|index| match gix::Url::try_from(*index) {
-							Ok(url) => config.wally_allowed.is_allowed(url),
-							Err(_) => false,
-						})
-						.is_none()
-					{
+					let allowed = match gix::Url::try_from(&*specifier.index) {
+						Ok(url) => config.wally_allowed.is_allowed(url),
+						Err(_) => false,
+					};
+
+					if !allowed {
 						return Err(RegistryError::InvalidArchive(format!(
 							"invalid index in wally dependency {specifier}"
 						)));

src/cli/commands/add.rs

@@ -77,7 +77,7 @@ impl AddCommand {
 					let specifier = DependencySpecifiers::Pesde(PesdeDependencySpecifier {
 						name: name.clone(),
 						version: version.clone().unwrap_or(VersionReq::STAR),
-						index: self.index,
+						index: self.index.unwrap_or_else(|| DEFAULT_INDEX_NAME.to_string()),
 						target: self.target,
 					});
 
@@ -102,7 +102,7 @@ impl AddCommand {
 						pesde::source::wally::specifier::WallyDependencySpecifier {
 							name: name.clone(),
 							version: version.clone().unwrap_or(VersionReq::STAR),
-							index: self.index,
+							index: self.index.unwrap_or_else(|| DEFAULT_INDEX_NAME.to_string()),
 						},
 					);
 
@@ -210,8 +210,8 @@ impl AddCommand {
 					field["target"] = toml_edit::value(version_id.target().to_string());
 				}
 
-				if let Some(index) = spec.index.filter(|i| i != DEFAULT_INDEX_NAME) {
-					field["index"] = toml_edit::value(index);
+				if spec.index != DEFAULT_INDEX_NAME {
+					field["index"] = toml_edit::value(spec.index);
 				}
 
 				println!(
@@ -228,8 +228,8 @@ impl AddCommand {
 				field["wally"] = toml_edit::value(name_str);
 				field["version"] = toml_edit::value(format!("^{}", version_id.version()));
 
-				if let Some(index) = spec.index.filter(|i| i != DEFAULT_INDEX_NAME) {
-					field["index"] = toml_edit::value(index);
+				if spec.index != DEFAULT_INDEX_NAME {
+					field["index"] = toml_edit::value(spec.index);
 				}
 
 				println!(

src/cli/commands/execute.rs

@@ -21,7 +21,7 @@ use pesde::{
 		},
 		PackageSources,
 	},
-	Project, RefreshedSources,
+	Project, RefreshedSources, DEFAULT_INDEX_NAME,
 };
 use semver::VersionReq;
 use std::{
@@ -86,7 +86,7 @@ impl ExecuteCommand {
 					let specifier = PesdeDependencySpecifier {
 						name: self.package.0.clone(),
 						version: version_req.clone(),
-						index: None,
+						index: DEFAULT_INDEX_NAME.into(),
 						target: None,
 					};
 

src/cli/commands/init.rs

@@ -199,7 +199,7 @@ impl InitCommand {
 						&PesdeDependencySpecifier {
 							name: scripts_pkg_name.clone(),
 							version: VersionReq::STAR,
-							index: None,
+							index: DEFAULT_INDEX_NAME.into(),
 							target: None,
 						},
 						&ResolveOptions {

src/cli/commands/publish.rs

@@ -429,37 +429,23 @@ info: otherwise, the file was deemed unnecessary, if you don't understand why, p
 		{
 			match specifier {
 				DependencySpecifiers::Pesde(specifier) => {
-					let index_name = specifier
-						.index
-						.as_deref()
-						.unwrap_or(DEFAULT_INDEX_NAME)
+					specifier.index = manifest
+						.indices
+						.get(&specifier.index)
+						.with_context(|| {
+							format!("index {} not found in indices field", specifier.index)
+						})?
 						.to_string();
-					specifier.index = Some(
-						manifest
-							.indices
-							.get(&index_name)
-							.with_context(|| {
-								format!("index {index_name} not found in indices field")
-							})?
-							.to_string(),
-					);
 				}
 				#[cfg(feature = "wally-compat")]
 				DependencySpecifiers::Wally(specifier) => {
-					let index_name = specifier
-						.index
-						.as_deref()
-						.unwrap_or(DEFAULT_INDEX_NAME)
+					specifier.index = manifest
+						.wally_indices
+						.get(&specifier.index)
+						.with_context(|| {
+							format!("index {} not found in wally_indices field", specifier.index)
+						})?
 						.to_string();
-					specifier.index = Some(
-						manifest
-							.wally_indices
-							.get(&index_name)
-							.with_context(|| {
-								format!("index {index_name} not found in wally_indices field")
-							})?
-							.to_string(),
-					);
 				}
 				DependencySpecifiers::Git(_) => {}
 				DependencySpecifiers::Workspace(spec) => {
@@ -503,13 +489,11 @@ info: otherwise, the file was deemed unnecessary, if you don't understand why, p
 							v => VersionReq::parse(&format!("{v}{}", manifest.version))
 								.with_context(|| format!("failed to parse version for {v}"))?,
 						},
-						index: Some(
-							manifest
-								.indices
-								.get(DEFAULT_INDEX_NAME)
-								.context("missing default index in workspace package manifest")?
-								.to_string(),
-						),
+						index: manifest
+							.indices
+							.get(DEFAULT_INDEX_NAME)
+							.context("missing default index in workspace package manifest")?
+							.to_string(),
 						target: Some(spec.target.unwrap_or(manifest.target.kind())),
 					});
 				}

src/lib.rs

@@ -66,6 +66,10 @@ pub(crate) const LINK_LIB_NO_FILE_FOUND: &str = "____pesde_no_export_file_found"
 /// The folder in which scripts are linked
 pub const SCRIPTS_LINK_FOLDER: &str = ".pesde";
 
+pub(crate) fn default_index_name() -> String {
+	DEFAULT_INDEX_NAME.into()
+}
+
 #[derive(Debug, Default)]
 struct AuthConfigShared {
 	tokens: HashMap<gix::Url, String>,

src/resolver.rs

@@ -8,7 +8,7 @@ use crate::{
 		traits::{PackageRef, PackageSource, RefreshOptions, ResolveOptions},
 		PackageSources,
 	},
-	Project, RefreshedSources, DEFAULT_INDEX_NAME,
+	Project, RefreshedSources,
 };
 use std::collections::{btree_map::Entry, HashMap, VecDeque};
 use tracing::{instrument, Instrument};
@@ -172,178 +172,176 @@ impl Project {
 
 		while let Some((specifier, ty, dependant, path, overridden, target)) = queue.pop_front() {
 			async {
-                let alias = path.last().unwrap();
-                let depth = path.len() - 1;
+				let alias = path.last().unwrap();
+				let depth = path.len() - 1;
 
-                tracing::debug!("resolving {specifier} ({ty:?})");
-                let source = match &specifier {
-                    DependencySpecifiers::Pesde(specifier) => {
-                        let index_url = if !is_published_package && (depth == 0 || overridden) {
-                            let index_name = specifier.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME);
+				tracing::debug!("resolving {specifier} ({ty:?})");
+				let source = match &specifier {
+					DependencySpecifiers::Pesde(specifier) => {
+						let index_url = if !is_published_package && (depth == 0 || overridden) {
+							manifest
+								.indices
+								.get(&specifier.index)
+								.ok_or(errors::DependencyGraphError::IndexNotFound(
+									specifier.index.to_string(),
+								))?
+								.clone()
+						} else {
+							specifier.index
+								.as_str()
+								.try_into()
+								// specifiers in indices store the index url in this field
+								.unwrap()
+						};
 
-                            manifest
-                                .indices
-                                .get(index_name)
-                                .ok_or(errors::DependencyGraphError::IndexNotFound(
-                                    index_name.to_string(),
-                                ))?
-                                .clone()
-                        } else {
-                            specifier.index.as_deref().unwrap()
-                                .try_into()
-                                // specifiers in indices store the index url in this field
-                                .unwrap()
-                        };
+						PackageSources::Pesde(PesdePackageSource::new(index_url))
+					}
+					#[cfg(feature = "wally-compat")]
+					DependencySpecifiers::Wally(specifier) => {
+						let index_url = if !is_published_package && (depth == 0 || overridden) {
+							manifest
+								.wally_indices
+								.get(&specifier.index)
+								.ok_or(errors::DependencyGraphError::WallyIndexNotFound(
+									specifier.index.to_string(),
+								))?
+								.clone()
+						} else {
+							specifier.index
+								.as_str()
+								.try_into()
+								// specifiers in indices store the index url in this field
+								.unwrap()
+						};
 
-                        PackageSources::Pesde(PesdePackageSource::new(index_url))
-                    }
-                    #[cfg(feature = "wally-compat")]
-                    DependencySpecifiers::Wally(specifier) => {
-                        let index_url = if !is_published_package && (depth == 0 || overridden) {
-                            let index_name = specifier.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME);
+						PackageSources::Wally(crate::source::wally::WallyPackageSource::new(index_url))
+					}
+					DependencySpecifiers::Git(specifier) => PackageSources::Git(
+						crate::source::git::GitPackageSource::new(specifier.repo.clone()),
+					),
+					DependencySpecifiers::Workspace(_) => {
+						PackageSources::Workspace(crate::source::workspace::WorkspacePackageSource)
+					}
+					DependencySpecifiers::Path(_) => {
+						PackageSources::Path(crate::source::path::PathPackageSource)
+					}
+				};
 
-                            manifest
-                                .wally_indices
-                                .get(index_name)
-                                .ok_or(errors::DependencyGraphError::WallyIndexNotFound(
-                                    index_name.to_string(),
-                                ))?
-                                .clone()
-                        } else {
-                            specifier.index.as_deref().unwrap()
-                                .try_into()
-                                // specifiers in indices store the index url in this field
-                                .unwrap()
-                        };
+				refreshed_sources.refresh(
+					&source,
+					&refresh_options,
+				)
+					.await
+					.map_err(|e| Box::new(e.into()))?;
 
-                        PackageSources::Wally(crate::source::wally::WallyPackageSource::new(index_url))
-                    }
-                    DependencySpecifiers::Git(specifier) => PackageSources::Git(
-                        crate::source::git::GitPackageSource::new(specifier.repo.clone()),
-                    ),
-                    DependencySpecifiers::Workspace(_) => {
-                        PackageSources::Workspace(crate::source::workspace::WorkspacePackageSource)
-                    }
-                    DependencySpecifiers::Path(_) => {
-                        PackageSources::Path(crate::source::path::PathPackageSource)
-                    }
-                };
+				let (name, resolved) = source
+					.resolve(&specifier, &ResolveOptions {
+						project: self.clone(),
+						target,
+						refreshed_sources: refreshed_sources.clone(),
+					})
+					.await
+					.map_err(|e| Box::new(e.into()))?;
 
-                refreshed_sources.refresh(
-                    &source,
-                    &refresh_options,
-                )
-                .await
-                .map_err(|e| Box::new(e.into()))?;
+				let Some(package_id) = graph
+					.keys()
+					.filter(|id| *id.name() == name && resolved.contains_key(id.version_id()))
+					.max()
+					.cloned()
+					.or_else(|| resolved.last_key_value().map(|(ver, _)| PackageId::new(name, ver.clone())))
+				else {
+					return Err(Box::new(errors::DependencyGraphError::NoMatchingVersion(
+						format!("{specifier} ({target})"),
+					)));
+				};
 
-                let (name, resolved) = source
-                    .resolve(&specifier, &ResolveOptions {
-                        project: self.clone(),
-                        target,
-                        refreshed_sources: refreshed_sources.clone(),
-                    })
-                    .await
-                    .map_err(|e| Box::new(e.into()))?;
+				let resolved_ty = if (is_published_package || depth == 0) && ty == DependencyType::Peer
+				{
+					DependencyType::Standard
+				} else {
+					ty
+				};
 
-                let Some(package_id) = graph
-                    .keys()
-                    .filter(|id| *id.name() == name && resolved.contains_key(id.version_id()))
-                    .max()
-                    .cloned()
-                    .or_else(|| resolved.last_key_value().map(|(ver, _)| PackageId::new(name, ver.clone())))
-                else {
-                    return Err(Box::new(errors::DependencyGraphError::NoMatchingVersion(
-                        format!("{specifier} ({target})"),
-                    )));
-                };
+				if let Some(dependant_id) = dependant {
+					graph
+						.get_mut(&dependant_id)
+						.expect("dependant package not found in graph")
+						.dependencies
+						.insert(package_id.clone(), alias.clone());
+				}
 
-                let resolved_ty = if (is_published_package || depth == 0) && ty == DependencyType::Peer
-                {
-                    DependencyType::Standard
-                } else {
-                    ty
-                };
+				let pkg_ref = &resolved[package_id.version_id()];
 
-                if let Some(dependant_id) = dependant {
-                    graph
-                        .get_mut(&dependant_id)
-                        .expect("dependant package not found in graph")
-                        .dependencies
-                        .insert(package_id.clone(), alias.clone());
-                }
+				if let Some(already_resolved) = graph.get_mut(&package_id) {
+					tracing::debug!("{package_id} already resolved");
 
-                let pkg_ref = &resolved[package_id.version_id()];
-
-                if let Some(already_resolved) = graph.get_mut(&package_id) {
-                    tracing::debug!("{package_id} already resolved");
-
-                    if std::mem::discriminant(&already_resolved.pkg_ref) != std::mem::discriminant(pkg_ref) {
-                        tracing::warn!(
+					if std::mem::discriminant(&already_resolved.pkg_ref) != std::mem::discriminant(pkg_ref) {
+						tracing::warn!(
                             "resolved package {package_id} has a different source than previously resolved one, this may cause issues",
                         );
-                    }
+					}
 
-                    if already_resolved.resolved_ty == DependencyType::Peer {
-                        already_resolved.resolved_ty = resolved_ty;
-                    }
+					if already_resolved.resolved_ty == DependencyType::Peer {
+						already_resolved.resolved_ty = resolved_ty;
+					}
 
-                    if ty == DependencyType::Peer && depth == 0 {
-                        already_resolved.is_peer = true;
-                    }
+					if ty == DependencyType::Peer && depth == 0 {
+						already_resolved.is_peer = true;
+					}
 
-                    if already_resolved.direct.is_none() && depth == 0 {
-                        already_resolved.direct = Some((alias.clone(), specifier.clone(), ty));
-                    }
+					if already_resolved.direct.is_none() && depth == 0 {
+						already_resolved.direct = Some((alias.clone(), specifier.clone(), ty));
+					}
 
-                    return Ok(());
-                }
+					return Ok(());
+				}
 
-                let node = DependencyGraphNode {
-                    direct: if depth == 0 {
-                        Some((alias.clone(), specifier.clone(), ty))
-                    } else {
-                        None
-                    },
-                    pkg_ref: pkg_ref.clone(),
-                    dependencies: Default::default(),
-                    resolved_ty,
-                    is_peer: if depth == 0 {
-                        false
-                    } else {
-                        ty == DependencyType::Peer
-                    },
-                };
-                insert_node(
-                    &mut graph,
-                    &package_id,
-                    node,
-                    depth == 0,
-                );
+				let node = DependencyGraphNode {
+					direct: if depth == 0 {
+						Some((alias.clone(), specifier.clone(), ty))
+					} else {
+						None
+					},
+					pkg_ref: pkg_ref.clone(),
+					dependencies: Default::default(),
+					resolved_ty,
+					is_peer: if depth == 0 {
+						false
+					} else {
+						ty == DependencyType::Peer
+					},
+				};
+				insert_node(
+					&mut graph,
+					&package_id,
+					node,
+					depth == 0,
+				);
 
-                tracing::debug!("resolved {package_id} from new dependency graph");
+				tracing::debug!("resolved {package_id} from new dependency graph");
 
-                for (dependency_alias, (dependency_spec, dependency_ty)) in
-                    pkg_ref.dependencies().clone()
-                {
-                    if dependency_ty == DependencyType::Dev {
-                        // dev dependencies of dependencies are to be ignored
-                        continue;
-                    }
+				for (dependency_alias, (dependency_spec, dependency_ty)) in
+					pkg_ref.dependencies().clone()
+				{
+					if dependency_ty == DependencyType::Dev {
+						// dev dependencies of dependencies are to be ignored
+						continue;
+					}
 
-                    let overridden = manifest.overrides.iter().find_map(|(key, spec)| {
-                        key.0.iter().find_map(|override_path| {
-                            // if the path up until the last element is the same as the current path,
-                            // and the last element in the path is the dependency alias,
-                            // then the specifier is to be overridden
-                            (path.len() == override_path.len() - 1
-                                && path == override_path[..override_path.len() - 1]
-                                && override_path.last() == Some(&dependency_alias))
-                                .then_some(spec)
-                        })
-                    });
+					let overridden = manifest.overrides.iter().find_map(|(key, spec)| {
+						key.0.iter().find_map(|override_path| {
+							// if the path up until the last element is the same as the current path,
+							// and the last element in the path is the dependency alias,
+							// then the specifier is to be overridden
+							(path.len() == override_path.len() - 1
+								&& path == override_path[..override_path.len() - 1]
+								&& override_path.last() == Some(&dependency_alias))
+								.then_some(spec)
+						})
+					});
 
-                    if overridden.is_some() {
-                        tracing::debug!(
+					if overridden.is_some() {
+						tracing::debug!(
                             "overridden specifier found for {} ({dependency_spec})",
                             path.iter()
                                 .map(Alias::as_str)
@@ -351,32 +349,32 @@ impl Project {
                                 .collect::<Vec<_>>()
                                 .join(">"),
                         );
-                    }
+					}
 
-                    queue.push_back((
-                        match overridden {
-                            Some(OverrideSpecifier::Specifier(spec)) => spec.clone(),
-                            Some(OverrideSpecifier::Alias(alias)) => all_current_dependencies.get(alias)
-                                .map(|(spec, _)| spec)
-                                .ok_or_else(|| errors::DependencyGraphError::AliasNotFound(alias.clone()))?
-                                .clone(),
-                            None => dependency_spec,
-                        },
-                        dependency_ty,
-                        Some(package_id.clone()),
-                        path.iter()
-                            .cloned()
-                            .chain(std::iter::once(dependency_alias))
-                            .collect(),
-                        overridden.is_some(),
-                        package_id.version_id().target(),
-                    ));
-                }
+					queue.push_back((
+						match overridden {
+							Some(OverrideSpecifier::Specifier(spec)) => spec.clone(),
+							Some(OverrideSpecifier::Alias(alias)) => all_current_dependencies.get(alias)
+								.map(|(spec, _)| spec)
+								.ok_or_else(|| errors::DependencyGraphError::AliasNotFound(alias.clone()))?
+								.clone(),
+							None => dependency_spec,
+						},
+						dependency_ty,
+						Some(package_id.clone()),
+						path.iter()
+							.cloned()
+							.chain(std::iter::once(dependency_alias))
+							.collect(),
+						overridden.is_some(),
+						package_id.version_id().target(),
+					));
+				}
 
-                Ok(())
-            }
-                .instrument(tracing::info_span!("resolve new/changed", path = path.iter().map(Alias::as_str).collect::<Vec<_>>().join(">")))
-                .await?;
+				Ok(())
+			}
+				.instrument(tracing::info_span!("resolve new/changed", path = path.iter().map(Alias::as_str).collect::<Vec<_>>().join(">")))
+				.await?;
 		}
 
 		for (id, node) in &mut graph {

src/source/git/mod.rs

@@ -13,7 +13,7 @@ use crate::{
 		IGNORED_FILES,
 	},
 	util::hash,
-	Project, DEFAULT_INDEX_NAME, LOCKFILE_FILE_NAME, MANIFEST_FILE_NAME,
+	Project, LOCKFILE_FILE_NAME, MANIFEST_FILE_NAME,
 };
 use fs_err::tokio as fs;
 use gix::{bstr::BStr, traverse::tree::Recorder, ObjectId, Url};
@@ -72,43 +72,29 @@ fn transform_pesde_dependencies(
 		.map(|(alias, (mut spec, ty))| {
 			match &mut spec {
 				DependencySpecifiers::Pesde(specifier) => {
-					let index_name = specifier
-						.index
-						.as_deref()
-						.unwrap_or(DEFAULT_INDEX_NAME)
+					specifier.index = manifest
+						.indices
+						.get(&specifier.index)
+						.ok_or_else(|| {
+							errors::ResolveError::PesdeIndexNotFound(
+								specifier.index.to_string(),
+								Box::new(repo_url.clone()),
+							)
+						})?
 						.to_string();
-					specifier.index = Some(
-						manifest
-							.indices
-							.get(&index_name)
-							.ok_or_else(|| {
-								errors::ResolveError::PesdeIndexNotFound(
-									index_name.clone(),
-									Box::new(repo_url.clone()),
-								)
-							})?
-							.to_string(),
-					);
 				}
 				#[cfg(feature = "wally-compat")]
 				DependencySpecifiers::Wally(specifier) => {
-					let index_name = specifier
-						.index
-						.as_deref()
-						.unwrap_or(DEFAULT_INDEX_NAME)
+					specifier.index = manifest
+						.wally_indices
+						.get(&specifier.index)
+						.ok_or_else(|| {
+							errors::ResolveError::WallyIndexNotFound(
+								specifier.index.to_string(),
+								Box::new(repo_url.clone()),
+							)
+						})?
 						.to_string();
-					specifier.index = Some(
-						manifest
-							.wally_indices
-							.get(&index_name)
-							.ok_or_else(|| {
-								errors::ResolveError::WallyIndexNotFound(
-									index_name.clone(),
-									Box::new(repo_url.clone()),
-								)
-							})?
-							.to_string(),
-					);
 				}
 				DependencySpecifiers::Git(_) => {}
 				DependencySpecifiers::Workspace(specifier) => {

src/source/path/mod.rs

@@ -11,7 +11,6 @@ use crate::{
 		traits::{DownloadOptions, GetTargetOptions, PackageSource, ResolveOptions},
 		ResolveResult,
 	},
-	DEFAULT_INDEX_NAME,
 };
 use std::collections::BTreeMap;
 use tracing::instrument;
@@ -49,37 +48,29 @@ impl PackageSource for PathPackageSource {
 				.map(|(alias, (mut spec, ty))| {
 					match &mut spec {
 						DependencySpecifiers::Pesde(spec) => {
-							let index_name = spec.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME);
-
-							spec.index = Some(
-								manifest
-									.indices
-									.get(index_name)
-									.ok_or_else(|| {
-										errors::ResolveError::IndexNotFound(
-											index_name.to_string(),
-											specifier.path.clone(),
-										)
-									})?
-									.to_string(),
-							)
+							spec.index = manifest
+								.indices
+								.get(&spec.index)
+								.ok_or_else(|| {
+									errors::ResolveError::IndexNotFound(
+										spec.index.to_string(),
+										specifier.path.clone(),
+									)
+								})?
+								.to_string();
 						}
 						#[cfg(feature = "wally-compat")]
 						DependencySpecifiers::Wally(spec) => {
-							let index_name = spec.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME);
-
-							spec.index = Some(
-								manifest
-									.wally_indices
-									.get(index_name)
-									.ok_or_else(|| {
-										errors::ResolveError::IndexNotFound(
-											index_name.to_string(),
-											specifier.path.clone(),
-										)
-									})?
-									.to_string(),
-							)
+							spec.index = manifest
+								.wally_indices
+								.get(&spec.index)
+								.ok_or_else(|| {
+									errors::ResolveError::IndexNotFound(
+										spec.index.to_string(),
+										specifier.path.clone(),
+									)
+								})?
+								.to_string();
 						}
 						DependencySpecifiers::Git(_) => {}
 						DependencySpecifiers::Workspace(_) => {}

src/source/pesde/specifier.rs

@@ -13,8 +13,8 @@ pub struct PesdeDependencySpecifier {
 	#[cfg_attr(test, schemars(with = "String"))]
 	pub version: VersionReq,
 	/// The index to use for the package
-	#[serde(default, skip_serializing_if = "Option::is_none")]
-	pub index: Option<String>,
+	#[serde(default = "crate::default_index_name")]
+	pub index: String,
 	/// The target to use for the package
 	#[serde(default, skip_serializing_if = "Option::is_none")]
 	pub target: Option<TargetKind>,

src/source/wally/manifest.rs

@@ -42,7 +42,8 @@ pub fn deserialize_specifiers<'de, D: Deserializer<'de>>(
 				WallyDependencySpecifier {
 					name: name.parse().map_err(serde::de::Error::custom)?,
 					version: VersionReq::parse(version).map_err(serde::de::Error::custom)?,
-					index: None,
+					// doesn't matter, will be replaced later
+					index: "".to_string(),
 				},
 			))
 		})
@@ -54,11 +55,11 @@ pub fn deserialize_specifiers<'de, D: Deserializer<'de>>(
 pub struct WallyManifest {
 	pub package: WallyPackage,
 	#[serde(default, deserialize_with = "deserialize_specifiers")]
-	pub dependencies: BTreeMap<Alias, WallyDependencySpecifier>,
+	dependencies: BTreeMap<Alias, WallyDependencySpecifier>,
 	#[serde(default, deserialize_with = "deserialize_specifiers")]
-	pub server_dependencies: BTreeMap<Alias, WallyDependencySpecifier>,
+	server_dependencies: BTreeMap<Alias, WallyDependencySpecifier>,
 	#[serde(default, deserialize_with = "deserialize_specifiers")]
-	pub dev_dependencies: BTreeMap<Alias, WallyDependencySpecifier>,
+	dev_dependencies: BTreeMap<Alias, WallyDependencySpecifier>,
 }
 
 impl WallyManifest {
@@ -77,7 +78,7 @@ impl WallyManifest {
 		] {
 			for (alias, spec) in deps {
 				let mut spec = spec.clone();
-				spec.index = Some(self.package.registry.to_string());
+				spec.index = self.package.registry.to_string();
 
 				if all_deps
 					.insert(alias.clone(), (DependencySpecifiers::Wally(spec), ty))

src/source/wally/specifier.rs

@@ -16,8 +16,8 @@ pub struct WallyDependencySpecifier {
 	#[cfg_attr(test, schemars(with = "String"))]
 	pub version: VersionReq,
 	/// The index to use for the package
-	#[serde(default, skip_serializing_if = "Option::is_none")]
-	pub index: Option<String>,
+	#[serde(default = "crate::default_index_name")]
+	pub index: String,
 }
 impl DependencySpecifier for WallyDependencySpecifier {}
 

src/source/workspace/mod.rs

@@ -11,7 +11,6 @@ use crate::{
 		workspace::pkg_ref::WorkspacePackageRef,
 		ResolveResult,
 	},
-	DEFAULT_INDEX_NAME,
 };
 use futures::StreamExt;
 use relative_path::RelativePathBuf;
@@ -82,33 +81,29 @@ impl PackageSource for WorkspacePackageSource {
 				.map(|(alias, (mut spec, ty))| {
 					match &mut spec {
 						DependencySpecifiers::Pesde(spec) => {
-							let index_name = spec.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME);
-
-							spec.index = Some(
-								manifest
-									.indices
-									.get(index_name)
-									.ok_or(errors::ResolveError::IndexNotFound(
-										index_name.to_string(),
+							spec.index = manifest
+								.indices
+								.get(&spec.index)
+								.ok_or_else(|| {
+									errors::ResolveError::IndexNotFound(
+										spec.index.to_string(),
 										manifest.name.to_string(),
-									))?
-									.to_string(),
-							)
+									)
+								})?
+								.to_string();
 						}
 						#[cfg(feature = "wally-compat")]
 						DependencySpecifiers::Wally(spec) => {
-							let index_name = spec.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME);
-
-							spec.index = Some(
-								manifest
-									.wally_indices
-									.get(index_name)
-									.ok_or(errors::ResolveError::IndexNotFound(
-										index_name.to_string(),
+							spec.index = manifest
+								.wally_indices
+								.get(&spec.index)
+								.ok_or_else(|| {
+									errors::ResolveError::IndexNotFound(
+										spec.index.to_string(),
 										manifest.name.to_string(),
-									))?
-									.to_string(),
-							)
+									)
+								})?
+								.to_string();
 						}
 						DependencySpecifiers::Git(_) => {}
 						DependencySpecifiers::Workspace(_) => {}