use KrateName NewType in more places, introduce "confirmed name" to params

syphar · syphar · commit c5a729fbc02e · 2025-11-30T08:48:21.000+01:00
diff --git a/src/db/types/krate_name.rs b/src/db/types/krate_name.rs
@@ -18,7 +18,17 @@ use std::{io::Write, str::FromStr};
 /// FIXME: this should actually come from some shared crate between the rust projects,
 /// so the amount of duplication is less.
 #[derive(
-    Debug, Clone, PartialEq, Eq, Hash, Deref, Into, Display, DeserializeFromStr, SerializeDisplay,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    Deref,
+    Into,
+    Display,
+    DeserializeFromStr,
+    SerializeDisplay,
+    bincode::Encode,
 )]
 pub struct KrateName(String);
 
diff --git a/src/web/crate_details.rs b/src/web/crate_details.rs
@@ -2,7 +2,10 @@ use crate::{
     AsyncStorage,
     db::{
         BuildId, CrateId, ReleaseId,
-        types::{BuildStatus, dependencies::ReleaseDependencyList, version::Version},
+        types::{
+            BuildStatus, dependencies::ReleaseDependencyList, krate_name::KrateName,
+            version::Version,
+        },
     },
     impl_axum_webpage,
     registry_api::OwnerKind,
@@ -36,7 +39,7 @@ use std::sync::Arc;
 // TODO: Add target name and versions
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct CrateDetails {
-    pub(crate) name: String,
+    pub(crate) name: KrateName,
     pub(crate) version: Version,
     pub(crate) description: Option<String>,
     pub(crate) owners: Vec<(String, String, OwnerKind)>,
@@ -136,7 +139,7 @@ impl CrateDetails {
             r#"SELECT
                 crates.id AS "crate_id: CrateId",
                 releases.id AS "release_id: ReleaseId",
-                crates.name,
+                crates.name as "name: KrateName",
                 releases.version,
                 releases.description,
                 releases.dependencies,
@@ -437,7 +440,7 @@ pub(crate) async fn releases_for_crate(
 #[template(path = "crate/details.html")]
 struct CrateDetailsPage {
     version: Version,
-    name: String,
+    name: KrateName,
     owners: Vec<(String, String, OwnerKind)>,
     metadata: MetaData,
     documented_items: Option<i32>,
diff --git a/src/web/extractors/rustdoc.rs b/src/web/extractors/rustdoc.rs
@@ -1,7 +1,7 @@
 //! special rustdoc extractors
 
 use crate::{
-    db::BuildId,
+    db::{BuildId, types::krate_name::KrateName},
     web::{
         MatchedRelease, MetaData, ReqVersion, error::AxumNope, escaped_uri::EscapedURI,
         extractors::Path, url_decode,
@@ -49,6 +49,7 @@ pub(crate) struct RustdocParams {
 
     original_uri: Option<EscapedURI>,
     name: String,
+    confirmed_name: Option<KrateName>,
     req_version: ReqVersion,
     doc_target: Option<String>,
     inner_path: Option<String>,
@@ -67,6 +68,7 @@ impl std::fmt::Debug for RustdocParams {
             .field("page_kind", &self.page_kind)
             .field("original_uri", &self.original_uri)
             .field("name", &self.name)
+            .field("confirmed_name", &self.confirmed_name)
             .field("req_version", &self.req_version)
             .field("doc_target", &self.doc_target)
             .field("inner_path", &self.inner_path)
@@ -165,6 +167,7 @@ impl RustdocParams {
     pub(crate) fn new(name: impl Into<String>) -> Self {
         Self {
             name: name.into().trim().into(),
+            confirmed_name: None,
             req_version: ReqVersion::default(),
             original_uri: None,
             doc_target: None,
@@ -199,11 +202,12 @@ impl RustdocParams {
     }
 
     pub(crate) fn from_metadata(metadata: &MetaData) -> Self {
-        RustdocParams::new(&metadata.name).apply_metadata(metadata)
+        RustdocParams::new(metadata.name.to_string()).apply_metadata(metadata)
     }
 
     pub(crate) fn apply_metadata(self, metadata: &MetaData) -> RustdocParams {
-        self.with_name(&metadata.name)
+        self.with_name(metadata.name.to_string())
+            .with_confirmed_name(metadata.name.clone())
             .with_req_version(&metadata.req_version)
             // first set the doc-target list
             .with_maybe_doc_targets(metadata.doc_targets.clone())
@@ -213,12 +217,13 @@ impl RustdocParams {
     }
 
     pub(crate) fn from_matched_release(matched_release: &MatchedRelease) -> Self {
-        RustdocParams::new(&matched_release.name).apply_matched_release(matched_release)
+        RustdocParams::new(matched_release.name.to_string()).apply_matched_release(matched_release)
     }
 
     pub(crate) fn apply_matched_release(self, matched_release: &MatchedRelease) -> RustdocParams {
         let release = &matched_release.release;
-        self.with_name(&matched_release.name)
+        self.with_name(matched_release.name.to_string())
+            .with_confirmed_name(matched_release.name.clone())
             .with_req_version(&matched_release.req_version)
             .with_maybe_doc_targets(release.doc_targets.as_deref())
             .with_maybe_default_target(release.default_target.as_deref())
@@ -235,6 +240,22 @@ impl RustdocParams {
         })
     }
 
+    pub(crate) fn confirmed_name(&self) -> Option<&KrateName> {
+        self.confirmed_name.as_ref()
+    }
+    pub(crate) fn with_maybe_confirmed_name(
+        self,
+        confirmed_name: Option<impl Into<KrateName>>,
+    ) -> Self {
+        self.update(|mut params| {
+            params.confirmed_name = confirmed_name.map(Into::into);
+            params
+        })
+    }
+    pub(crate) fn with_confirmed_name(self, confirmed_name: impl Into<KrateName>) -> Self {
+        self.with_maybe_confirmed_name(Some(confirmed_name))
+    }
+
     pub(crate) fn req_version(&self) -> &ReqVersion {
         &self.req_version
     }
diff --git a/src/web/mod.rs b/src/web/mod.rs
@@ -5,7 +5,7 @@ pub mod page;
 use crate::{
     db::{
         CrateId,
-        types::{BuildStatus, version::Version},
+        types::{BuildStatus, krate_name::KrateName, version::Version},
     },
     utils::{get_correct_docsrs_style_file, report_error},
     web::{
@@ -201,12 +201,12 @@ impl TryFrom<&str> for ReqVersion {
 #[derive(Debug)]
 pub(crate) struct MatchedRelease {
     /// crate name
-    pub name: String,
+    pub name: KrateName,
 
     /// The crate name that was found when attempting to load a crate release.
     /// `match_version` will attempt to match a provided crate name against similar crate names with
     /// dashes (`-`) replaced with underscores (`_`) and vice versa.
-    pub corrected_name: Option<String>,
+    pub corrected_name: Option<KrateName>,
 
     /// what kind of version did we get in the request? ("latest", semver, exact)
     pub req_version: ReqVersion,
@@ -344,12 +344,12 @@ async fn match_version(
     name: &str,
     input_version: &ReqVersion,
 ) -> Result<MatchedRelease, AxumNope> {
-    let (crate_id, corrected_name) = {
+    let (crate_id, name, corrected_name) = {
         let row = sqlx::query!(
             r#"
              SELECT
                 id as "id: CrateId",
-                name
+                name as "name: KrateName"
              FROM crates
              WHERE normalize_crate_name(name) = normalize_crate_name($1)"#,
             name,
@@ -359,10 +359,14 @@ async fn match_version(
         .context("error fetching crate")?
         .ok_or(AxumNope::CrateNotFound)?;
 
+        let name: KrateName = name
+            .parse()
+            .expect("here we know it's valid, because we found it after normalizing");
+
         if row.name != name {
-            (row.id, Some(row.name))
+            (row.id, name, Some(row.name))
         } else {
-            (row.id, None)
+            (row.id, name, None)
         }
     };
 
@@ -383,7 +387,7 @@ async fn match_version(
                 .find(|release| &release.version == parsed_req_version)
             {
                 return Ok(MatchedRelease {
-                    name: name.to_owned(),
+                    name,
                     corrected_name,
                     req_version: input_version.clone(),
                     release: release.clone(),
@@ -689,7 +693,7 @@ where
 /// MetaData used in header
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, bincode::Encode)]
 pub(crate) struct MetaData {
-    pub(crate) name: String,
+    pub(crate) name: KrateName,
     /// The exact version of the release being shown.
     pub(crate) version: Version,
     /// The version identifier in the request that was used to request this page.
@@ -718,7 +722,7 @@ impl MetaData {
     ) -> Result<MetaData> {
         let row = sqlx::query!(
             r#"SELECT
-                crates.name,
+                crates.name as "name: KrateName",
                 releases.version,
                 releases.description,
                 releases.target_name,
@@ -1208,7 +1212,7 @@ mod test {
     #[test]
     fn serialize_metadata() {
         let mut metadata = MetaData {
-            name: "serde".to_string(),
+            name: "serde".parse().unwrap(),
             version: "1.0.0".parse().unwrap(),
             req_version: ReqVersion::Latest,
             description: Some("serde does stuff".to_string()),
@@ -1295,7 +1299,7 @@ mod test {
             assert_eq!(
                 metadata.unwrap(),
                 MetaData {
-                    name: "foo".to_string(),
+                    name: "foo".parse().unwrap(),
                     version: "0.1.0".parse().unwrap(),
                     req_version: ReqVersion::Latest,
                     description: Some("Fake package".to_string()),
