feat(parakeet): really incomplete com.atproto.repo.getRecord impl

parakeet/src/xrpc/com_atproto/mod.rs

···
 use axum::Router;
 
 mod identity;
+mod repo;
 
 #[rustfmt::skip]
 pub fn routes() -> Router<crate::GlobalState> {
     Router::new()
         .route("/com.atproto.identity.resolveHandle", get(identity::resolve_handle))
+        .route("/com.atproto.repo.getRecord", get(repo::get_record))
 }

parakeet/src/xrpc/com_atproto/repo.rs

···
+use crate::xrpc::check_actor_status;
+use crate::xrpc::error::{Error, XrpcResult};
+use crate::xrpc::extract::AtpAuth;
+use crate::GlobalState;
+use axum::extract::{Query, State};
+use axum::Json;
+use diesel::prelude::*;
+use diesel_async::RunQueryDsl;
+use parakeet_db::schema;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Debug, Deserialize)]
+pub struct GetRecordQuery {
+    pub repo: String,
+    pub collection: String,
+    pub rkey: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct GetRecordRes {
+    pub uri: String,
+    pub cid: String,
+    pub value: Value,
+}
+
+pub async fn get_record(
+    State(state): State<GlobalState>,
+    _maybe_auth: Option<AtpAuth>,
+    Query(query): Query<GetRecordQuery>,
+) -> XrpcResult<Json<GetRecordRes>> {
+    let mut conn = state.pool.get().await?;
+
+    check_actor_status(&mut conn, &query.repo).await?;
+
+    let at_uri = format!("at://{}/{}/{}", &query.repo, &query.collection, &query.rkey);
+
+    let (cid, value) = match query.collection.as_str() {
+        "app.bsky.feed.generator" => {
+            // we don't store the full data so this returns partial
+            let (cid, service_did) = schema::feedgens::table
+                .select((schema::feedgens::cid, schema::feedgens::service_did))
+                .find(&at_uri)
+                .get_result::<(String, String)>(&mut conn)
+                .await?;
+
+            (
+                cid,
+                serde_json::json!({
+                    "$type": "app.bsky.feed.generator",
+                    "did": service_did,
+                }),
+            )
+        }
+        "app.bsky.feed.post" => {
+            schema::posts::table
+                .select((schema::posts::cid, schema::posts::record))
+                .find(&at_uri)
+                .get_result::<(String, Value)>(&mut conn)
+                .await?
+        }
+        "app.bsky.graph.starterpack" => {
+            schema::starterpacks::table
+                .select((schema::starterpacks::cid, schema::starterpacks::record))
+                .find(&at_uri)
+                .get_result::<(String, Value)>(&mut conn)
+                .await?
+        }
+        _ => return Err(Error::invalid_request(None)),
+    };
+
+    Ok(Json(GetRecordRes {
+        uri: at_uri,
+        cid,
+        value,
+    }))
+}