add krate-name validation to rustdoc parameter extraction

Author: syphar

.sqlx/query-1be3826465e3cd76738b3bfc9d46df14795d1f18830783080bf3a58b909ab16a.json

@@ -10,6 +10,12 @@ edition = "2024"
 
 [workspace]
 members = ["crates/*"]
+exclude = [
+    "ignored",
+    "tests",
+    ".workspace",
+    ".rustwide-docker",
+]
 
 [dependencies]
 sentry = { version = "0.46.0", features = ["panic", "tracing", "tower-http", "anyhow", "backtrace"] }

.sqlx/query-543694448dbb43af41dc18c29017c5b211f45f7722811fdcabea26f796d4514b.json

@@ -6,10 +6,10 @@ use sqlx::{
     Decode, Encode, Postgres,
     encode::IsNull,
     error::BoxDynError,
-    postgres::{PgArgumentBuffer, PgTypeInfo, PgValueRef},
+    postgres::{PgArgumentBuffer, PgHasArrayType, PgTypeInfo, PgValueRef},
     prelude::*,
 };
-use std::{io::Write, str::FromStr};
+use std::{borrow::Cow, io::Write, str::FromStr};
 
 /// validated crate name
 ///
@@ -31,7 +31,14 @@ use std::{io::Write, str::FromStr};
     SerializeDisplay,
     bincode::Encode,
 )]
-pub struct KrateName(String);
+pub struct KrateName(Cow<'static, str>);
+
+impl KrateName {
+    #[cfg(test)]
+    pub(crate) const fn from_static(s: &'static str) -> Self {
+        KrateName(Cow::Borrowed(s))
+    }
+}
 
 impl From<&KrateName> for KrateName {
     fn from(krate_name: &KrateName) -> Self {
@@ -44,7 +51,7 @@ impl FromStr for KrateName {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         validate_crate_name("crate", s)?;
-        Ok(KrateName(s.to_string()))
+        Ok(KrateName(Cow::Owned(s.to_string())))
     }
 }
 
@@ -67,8 +74,21 @@ impl<'q> Encode<'q, Postgres> for KrateName {
 
 impl<'r> Decode<'r, Postgres> for KrateName {
     fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
+        // future improvement: we could also avoid the allocation here
+        // and return a Cow::Borrowed while reading from the DB.
+        // But this would mean the lifetime leaks into the whole codebase.
         let s: &str = Decode::<Postgres>::decode(value)?;
-        Ok(Self(s.parse()?))
+        Ok(Self(Cow::Owned(s.parse()?)))
+    }
+}
+
+impl PgHasArrayType for KrateName {
+    fn array_type_info() -> PgTypeInfo {
+        <&str as PgHasArrayType>::array_type_info()
+    }
+
+    fn array_compatible(ty: &PgTypeInfo) -> bool {
+        <&str as PgHasArrayType>::array_compatible(ty)
     }
 }
 

.sqlx/query-af663241b6e7d77402847d57ef9a1d69412ea5af6d0b6562644fe913bac2e1df.json

@@ -1,4 +1,6 @@
-use crate::{db::types::version::Version, error::Result};
+use crate::db::types::krate_name::KrateName;
+use crate::web::ReqVersion;
+use crate::{db::types::version::Version, error::Result, web::extractors::rustdoc::RustdocParams};
 use anyhow::{Context, bail};
 use rustwide::{Toolchain, Workspace, cmd::Command};
 use semver::VersionReq;
@@ -135,6 +137,19 @@ pub(crate) struct Dependency {
     pub(crate) optional: bool,
 }
 
+impl Dependency {
+    pub(crate) fn rustdoc_params(&self) -> RustdocParams {
+        RustdocParams::new(
+            // I validated in the database, which makes me assume that renames are
+            // handled before storing the deps into the column.
+            self.name
+                .parse::<KrateName>()
+                .expect("we validated that the dep name is always a valid KrateName"),
+        )
+        .with_req_version(ReqVersion::Semver(self.req.clone()))
+    }
+}
+
 impl bincode::Encode for Dependency {
     fn encode<E: bincode::enc::Encoder>(
         &self,

.sqlx/query-bdddad099e891bb45ba3703d7144160056d6cb620c55be459ead0f95c3523035.json

@@ -76,7 +76,7 @@ pub(crate) async fn build_details_handler(
         .into_canonical_req_version_or_else(|confirmed_name, version| {
             let params = params
                 .clone()
-                .with_confirmed_name(Some(confirmed_name))
+                .with_name(confirmed_name)
                 .with_req_version(version);
             AxumNope::Redirect(
                 params.build_details_url(id, build_params.filename.as_deref()),