fix issues from `cargo clippy`

src/backfill/load_car.rs

···
 #[derive(Error, Debug)]
 pub enum Error {
     #[error("Error loading car file: {}", .0)]
-    ClientError(#[from] jacquard::error::ClientError),
+    Client(#[from] jacquard::error::ClientError),
     #[error("Error loading car file: {}", .0)]
-    RepoError(#[from] jacquard_repo::RepoError),
+    Repo(#[from] jacquard_repo::RepoError),
     #[error("Missing root block from car file (malformed car file)")]
     MissingRoot,
 }
···
 use std::cmp::Ordering;
 impl PartialOrd<Tid> for Car {
     fn partial_cmp(&self, other: &Tid) -> Option<Ordering> {
-        return match self.rev.compare_to(other) {
+        match self.rev.compare_to(other) {
             1 => Some(Ordering::Greater),
             0 => Some(Ordering::Equal),
             -1 => Some(Ordering::Less),
             _ => None,
-        };
+        }
     }
 }
 
···
     let res = agent.xrpc(pds).send(&req).await?;
 
     let car = res.buffer();
-    let car = jacquard_repo::car::parse_car_bytes(&car).await?;
+    let car = jacquard_repo::car::parse_car_bytes(car).await?;
 
     let storage = jacquard_repo::storage::MemoryBlockStore::new_from_blocks(car.blocks);
 

src/backfill/mod.rs

···
     #[error("Error parsing TID: {}", .0)]
     TidParse(#[from] jacquard::types::string::AtStrError),
     #[error("{}", .0)]
-    GetCarError(#[from] crate::backfill::load_car::Error),
+    GetCar(#[from] crate::backfill::load_car::Error),
     #[error(
         "The database claims to be more up to date than the PDS.
 Most likely either the PDS or repo is broken, or the database has been corrupted.
···
     )]
     DbTidTooLow,
     #[error("Database error: {}", .0)]
-    DbError(#[from] sqlx::Error),
+    Db(#[from] sqlx::Error),
     #[error("{}", .0)]
-    ParseCarError(#[from] crate::backfill::parse_car::Error),
+    ParseCar(#[from] crate::backfill::parse_car::Error),
 }
 
 pub async fn backfill(
···
     let _ = query!("DELETE FROM records").execute(conn).await?;
 
     let data = parse_car(&car).await?;
-    let mut data = data.chunks(DB_MAX_REQ / 4);
+    let data = data.chunks(DB_MAX_REQ / 4);
 
     if let Some(time) = time {
         println!("Parsed car file ({:?})", time.elapsed());
     }
     let time = time.map(|_| std::time::Instant::now());
 
-    while let Some(data) = data.next() {
+    for data in data {
         let mut query = sqlx::QueryBuilder::new("INSERT INTO records(collection, rkey, record) ");
         query.push_values(
             data,
···
             },
         );
 
-        match query.build().execute(conn).await {
-            Err(err) => {
-                // couldnt backfill so go nuclear
-                // this is program startup so its prolly safe lol
-                println!("Got error \"{}\"\nDeleting records and exiting...", err);
-                let _ = query!("DELETE FROM records").execute(conn).await?;
-                panic!()
-            }
-            _ => {}
+        if let Err(err) = query.build().execute(conn).await {
+            // couldnt backfill so go nuclear
+            // this is program startup so its prolly safe lol
+            println!("Got error \"{}\"\nDeleting records and exiting...", err);
+            let _ = query!("DELETE FROM records").execute(conn).await?;
+            panic!()
         };
     }
 
···
         println!("Saved to database ({:?})", time.elapsed());
     }
 
-    match query!(
+    if let Err(err) = query!(
         "UPDATE meta SET rev = $1 WHERE did = $2",
         car.rev.to_string(),
         config::USER.to_string()
···
     .execute(conn)
     .await
     {
-        Err(err) => {
-            // couldnt save tid so go nuclear
-            // this is program startup so its prolly safe lol
-            println!("Got error \"{}\"\nDeleting records and exiting...", err);
-            let _ = query!("DELETE FROM records").execute(conn).await?;
-            panic!()
-        }
-        _ => {}
+        // couldnt save tid so go nuclear
+        // this is program startup so its prolly safe lol
+        println!("Got error \"{}\"\nDeleting records and exiting...", err);
+        let _ = query!("DELETE FROM records").execute(conn).await?;
+        panic!()
     };
 
     Ok(())

src/backfill/parse_car.rs

···
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("Error getting records from car file: {}", .0)]
-    RepoError(#[from] jacquard_repo::RepoError),
+    Repo(#[from] jacquard_repo::RepoError),
     #[error("Missing CID from car file")]
     MissingCid,
     #[error("Could not decode record: {}", .0)]
-    DecodeError(#[from] serde_ipld_dagcbor::DecodeError<std::convert::Infallible>),
+    Decode(#[from] serde_ipld_dagcbor::DecodeError<std::convert::Infallible>),
     #[error("Could not convert into json: {}", .0)]
-    IpldToJsonError(#[from] crate::utils::ipld_json::Error),
+    IpldToJson(#[from] crate::utils::ipld_json::Error),
     #[error("Could not break {} into a collection and rkey", .0)]
     MalformedRecordKey(SmolStr),
 }

src/utils/ipld_json.rs

···
 #[derive(Error, Debug)]
 pub enum Error {
     #[error("CID error: {}", .0)]
-    CidError(#[from] ipld_core::cid::Error),
+    Cid(#[from] ipld_core::cid::Error),
     #[error("Number too big: {0} > {1} || {0} < {2}", .val, u64::MAX, i64::MIN)]
     IntInvalidSize { val: i128 },
     #[error("{} was NaN or Infinity", .0)]
···
     Ok(match data {
         Ipld::Null => Value::Null,
         Ipld::Bool(bool) => Value::Bool(*bool),
-        Ipld::Integer(int) => Value::Number(
-            Number::from_i128(*int).ok_or_else(|| Error::IntInvalidSize { val: *int })?,
-        ),
+        Ipld::Integer(int) => {
+            Value::Number(Number::from_i128(*int).ok_or(Error::IntInvalidSize { val: *int })?)
+        }
         Ipld::Float(float) => {
             warn!("Got float in IPLD data: {}", float);
-            Value::Number(Number::from_f64(*float).ok_or_else(|| Error::FloatInvalidSize(*float))?)
+            Value::Number(Number::from_f64(*float).ok_or(Error::FloatInvalidSize(*float))?)
         }
         Ipld::String(str) => Value::String(str.clone()),
         Ipld::Bytes(items) => json!({ "$bytes": BASE64_STANDARD_NO_PAD.encode(items) }),
         Ipld::List(iplds) => Value::Array(
             iplds
-                .into_iter()
-                .map(|x| ipld_to_json_value(x))
+                .iter()
+                .map(ipld_to_json_value)
                 .collect::<Result<Vec<_>, _>>()?,
         ),
         Ipld::Map(map) => Value::Object(
-            map.into_iter()
+            map.iter()
                 .map(|(k, v)| Ok::<_, Error>((k.clone(), ipld_to_json_value(v)?)))
                 .collect::<Result<Map<String, Value>, _>>()?,
         ),

src/utils/resolver.rs

···
 use thiserror::Error;
 
 #[derive(Debug, Error)]
-pub enum ResolveError {
+pub enum Error {
     #[error("Identity error: {}", .0)]
-    IdentityError(#[from] jacquard::identity::resolver::IdentityError),
+    IdentityError(Box<jacquard::identity::resolver::IdentityError>),
     #[error("Missing domain")]
     MissingDomain,
 }
 
-pub async fn resolve(did: &Did<'_>) -> Result<String, ResolveError> {
+impl From<jacquard::identity::resolver::IdentityError> for Error {
+    fn from(value: jacquard::identity::resolver::IdentityError) -> Self {
+        Self::IdentityError(Box::new(value))
+    }
+}
+
+pub async fn resolve(did: &Did<'_>) -> Result<String, Error> {
     // resolve did to pds
     let resolver = jacquard::identity::PublicResolver::default();
     let pds = resolver.pds_for_did(did).await?;
     let Some(pds) = pds.domain() else {
-        return Err(ResolveError::MissingDomain);
+        return Err(Error::MissingDomain);
     };
     Ok(String::from(pds))
 }