refactor: add 'com.atproto.repo.listRecords' to lexicon and use when fetching public keys

Signed-off-by: tjh <did:plc:65gha4t3avpfpzmvpbwovss7>

crates/knot/src/model/knot_state.rs

···
 use identity::Did;
 use identity::Resolver;
+use lexicon::com::atproto::repo::list_records;
 use oauth::public_key::PublicKey;
 use std::collections::HashMap;
 use std::path::PathBuf;
···
             .ok_or(anyhow::anyhow!("DID document does not declare a pds"))?
             .service_endpoint;
 
-        let response: crate::atproto::Response<LexiconPublicKey> = self
+        let response = self
             .public_http
             .get(list_records_url(pds.clone(), "sh.tangled.publicKey", did))
             .send()
             .await?
-            .json()
+            .error_for_status()?
+            .bytes()
             .await?;
 
-        Ok(response
-            .records
-            .into_iter()
-            .filter_map(|rec| PublicKey::from_openssh(&rec.value.key).ok())
+        let result: list_records::Output<LexiconPublicKey> = serde_json::from_slice(&response)?;
+        Ok(result
+            .records()
+            .filter_map(|rec| {
+                PublicKey::from_openssh(&rec.value.key)
+                    .inspect_err(|e| {
+                        tracing::error!(?e, ?did, "failed to parse public key from collection")
+                    })
+                    .ok()
+            })
             .collect())
     }
 }

crates/lexicon/src/com.rs

···
+pub mod atproto;

crates/lexicon/src/com/atproto.rs

···
+pub mod repo;

crates/lexicon/src/com/atproto/repo.rs

···
+pub mod list_records {
+    //!
+    //! List a range of records in a repository, matching a specific
+    //! collection. Does not require auth.
+    //!
+    //! <https://docs.bsky.app/docs/api/com-atproto-repo-list-records>
+    //!
+    use serde::{Deserialize, Serialize};
+    use std::borrow::Cow;
+
+    #[derive(Debug, Deserialize, Serialize)]
+    pub struct Input<'a> {
+        /// The handle or DID of the repo.
+        #[serde(borrow)]
+        pub repo: Cow<'a, str>,
+
+        /// The NSID of the record type.
+        #[serde(borrow)]
+        pub collection: Cow<'a, str>,
+
+        /// The number of records to return.
+        ///
+        /// Possible values: 0..=100.
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub limit: Option<usize>,
+
+        #[serde(borrow, skip_serializing_if = "Option::is_none")]
+        pub cursor: Option<Cow<'a, str>>,
+
+        /// Flag to reverse the order of the returned records.
+        #[serde(default)]
+        pub reverse: bool,
+    }
+
+    #[derive(Debug, Deserialize, Serialize)]
+    pub struct Output<'a, T> {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub cursor: Option<Cow<'a, str>>,
+
+        #[serde(borrow)]
+        pub records: Vec<Record<'a, T>>,
+    }
+
+    #[derive(Debug, Deserialize, Serialize)]
+    pub struct Record<'a, T> {
+        #[serde(borrow)]
+        pub uri: Cow<'a, str>,
+
+        #[serde(borrow)]
+        pub cid: Cow<'a, str>,
+
+        pub value: T,
+    }
+
+    impl<'a, T> Output<'a, T> {
+        pub fn records(&self) -> impl Iterator<Item = &Record<'a, T>> {
+            self.records.iter()
+        }
+    }
+}

crates/lexicon/src/lib.rs

···
 //! When you're too lazy to setup codegen, not lazy enough to not write them
 //! all out manually.
 //!
+pub mod com;
 pub mod sh;
 
 /// Types which aren't part of the lexicon, but are used for serializing