models/version: Replace String with &str for NewVersion struct fields

src/controllers/krate/publish.rs

@@ -351,26 +351,26 @@ pub async fn publish(app: AppState, req: BytesRequest) -> AppResult<Json<GoodCra
             // the `name` field is required for `bin` targets, so we can ignore `None` values via
             // `filter_map()` here.
             let bin_names = tarball_info.manifest.bin
-                .into_iter()
-                .filter_map(|bin| bin.name.clone())
-                .collect();
+                .iter()
+                .filter_map(|bin| bin.name.as_deref())
+                .collect::<Vec<_>>();
 
             // Read tarball from request
             let hex_cksum: String = Sha256::digest(&tarball_bytes).encode_hex();
 
             // Persist the new version of this crate
             let version = NewVersion::builder(krate.id, &version_string)
                 .features(&features)?
-                .license(license)
+                .license(license.as_deref())
                 // Downcast is okay because the file length must be less than the max upload size
                 // to get here, and max upload sizes are way less than i32 max
                 .size(content_length as i32)
                 .published_by(user.id)
-                .checksum(hex_cksum)
-                .links(package.links)
-                .rust_version(rust_version)
+                .checksum(&hex_cksum)
+                .links(package.links.as_deref())
+                .rust_version(rust_version.as_deref())
                 .has_lib(tarball_info.manifest.lib.is_some())
-                .bin_names(bin_names)
+                .bin_names(bin_names.as_slice())
                 .build()
                 .map_err(|error| internal(error.to_string()))?
                 .save(conn, &verified_email_address)?;

src/models/version.rs

@@ -79,32 +79,31 @@ impl Version {
 
 #[derive(Insertable, Debug, Builder)]
 #[diesel(table_name = versions, check_for_backend(diesel::pg::Pg))]
-pub struct NewVersion {
+pub struct NewVersion<'a> {
     crate_id: i32,
-    num: String,
+    num: &'a str,
     #[builder(
         default = "serde_json::Value::Object(Default::default())",
         setter(custom)
     )]
     features: serde_json::Value,
     #[builder(default)]
-    license: Option<String>,
+    license: Option<&'a str>,
     #[builder(default, setter(name = "size"))]
     crate_size: i32,
     published_by: i32,
-    #[builder(setter(into))]
-    checksum: String,
+    checksum: &'a str,
     #[builder(default)]
-    links: Option<String>,
+    links: Option<&'a str>,
     #[builder(default)]
-    rust_version: Option<String>,
+    rust_version: Option<&'a str>,
     #[builder(default, setter(strip_option))]
     pub has_lib: Option<bool>,
     #[builder(default, setter(strip_option))]
-    pub bin_names: Option<Vec<String>>,
+    pub bin_names: Option<&'a [&'a str]>,
 }
 
-impl NewVersionBuilder {
+impl NewVersionBuilder<'_> {
     pub fn features(
         &mut self,
         features: &BTreeMap<String, Vec<String>>,
@@ -118,15 +117,14 @@ impl NewVersionBuilder {
         const DUMMY_CHECKSUM: &str =
             "0000000000000000000000000000000000000000000000000000000000000000";
 
-        self.checksum = Some(DUMMY_CHECKSUM.to_string());
-        self
+        self.checksum(DUMMY_CHECKSUM)
     }
 }
 
-impl NewVersion {
-    pub fn builder(crate_id: i32, version: impl Into<String>) -> NewVersionBuilder {
+impl NewVersion<'_> {
+    pub fn builder(crate_id: i32, version: &str) -> NewVersionBuilder<'_> {
         let mut builder = NewVersionBuilder::default();
-        builder.crate_id(crate_id).num(version.into());
+        builder.crate_id(crate_id).num(version);
         builder
     }
 
@@ -135,7 +133,7 @@ impl NewVersion {
         use diesel::{insert_into, select};
 
         conn.transaction(|conn| {
-            let num_no_build = strip_build_metadata(&self.num);
+            let num_no_build = strip_build_metadata(self.num);
 
             let already_uploaded = versions::table
                 .filter(versions::crate_id.eq(self.crate_id))

src/tests/builders/version.rs

@@ -99,14 +99,16 @@ impl VersionBuilder {
     ) -> AppResult<Version> {
         use diesel::{insert_into, update};
 
-        let new_version = NewVersion::builder(crate_id, self.num.to_string())
+        let version = self.num.to_string();
+
+        let new_version = NewVersion::builder(crate_id, &version)
             .features(&self.features)?
-            .license(self.license)
+            .license(self.license.as_deref())
             .size(self.size)
             .published_by(published_by)
-            .checksum(self.checksum)
-            .links(self.links)
-            .rust_version(self.rust_version)
+            .checksum(&self.checksum)
+            .links(self.links.as_deref())
+            .rust_version(self.rust_version.as_deref())
             .build()
             .map_err(|error| internal(error.to_string()))?;