misc: Cleanup old code

cli/src/main.rs

@@ -3,9 +3,7 @@ use futures::{stream, StreamExt, TryStreamExt};
 use ipfs::IpfsClient;
 use sdk::{ids, pb::grc20};
 use sink::{kg::{
-    self,
-    entity::{Entity, EntityNode},
-}, ops::conversions};
+    self, mapping::DefaultAttributes,}, ops::conversions};
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 
@@ -46,21 +44,19 @@ async fn main() -> anyhow::Result<()> {
             unimplemented!()
         }
         Command::Describe { id } => {
-            let entity_node = kg_client
-                .find_node_by_id::<EntityNode>(&id)
+            let entity = kg_client
+                .find_node_by_id::<DefaultAttributes>(&id)
                 .await?
                 .expect("Entity not found");
 
-            let entity = Entity::from_entity(kg_client.clone(), entity_node.attributes().clone());
+            println!("Entity: {}", entity.name_or_id());
 
-            println!("Entity: {}", entity);
-
-            let attributes = entity.attributes().await?;
+            let attributes = kg_client.attribute_nodes::<DefaultAttributes>(entity.id()).await?;
 
             for attribute in attributes {
-                println!("\tAttribute: {}", attribute);
-                if let Some(value_type) = attribute.value_type().await? {
-                    println!("\t\tValue type: {}", value_type);
+                println!("\tAttribute: {}", attribute.name_or_id());
+                if let Some(value_type) = kg_client.value_type_node::<DefaultAttributes>(attribute.id()).await? {
+                    println!("\t\tValue type: {}", value_type.name_or_id());
                 }
             }
         }

codegen/src/lib.rs

@@ -164,7 +164,7 @@ pub async fn gen_type(kg: &sink::kg::Client, entity: &Node<Named>) -> anyhow::Re
 
     let typed_attrs = stream::iter(attrs.unique().fix_name_collisions())
         .then(|attr| async move {
-            let value_type = kg.value_type_nodes(attr.id()).await?;
+            let value_type = kg.value_type_node(attr.id()).await?;
             Ok::<_, anyhow::Error>((attr, value_type))
         })
         .try_collect::<Vec<_>>()

sink/src/events/vote_cast.rs

@@ -6,7 +6,7 @@ use sdk::{
 };
 use web3_utils::checksum_address;
 
-use crate::{kg::mapping::Relation, neo4j_utils::Neo4jExt};
+use crate::kg::mapping::Relation;
 
 use super::{handler::HandlerError, EventHandler};
 
@@ -24,8 +24,8 @@ impl EventHandler {
         ) {
             // Space found
             (Ok(Some(space)), Ok(_)) | (Ok(None), Ok(Some(space))) => {
-                let proposal = self.kg.neo4j
-                    .find_one::<models::Proposal>(neo4rs::query(&format!(
+                let proposal = self.kg
+                    .find_node::<models::Proposal>(neo4rs::query(&format!(
                         "MATCH (p:`{PROPOSAL_TYPE}` {{onchain_proposal_id: $onchain_proposal_id}})<-[:`{PROPOSALS}`]-(:`{INDEXED_SPACE}` {{id: $space_id}}) RETURN p",
                         PROPOSAL_TYPE = system_ids::PROPOSAL_TYPE,
                         PROPOSALS = system_ids::PROPOSALS,
@@ -38,8 +38,7 @@ impl EventHandler {
 
                 let account = self
                     .kg
-                    .neo4j
-                    .find_one::<models::GeoAccount>(
+                    .find_node::<models::GeoAccount>(
                         neo4rs::query(&format!(
                             "MATCH (a:`{ACCOUNT}` {{address: $address}}) RETURN a",
                             ACCOUNT = system_ids::GEO_ACCOUNT,
@@ -65,8 +64,8 @@ impl EventHandler {
                                 Relation::new(
                                     INDEXER_SPACE_ID,
                                     &vote_cast.id.clone(),
-                                    &account.id,
-                                    &proposal.id,
+                                    &account.id(),
+                                    &proposal.id(),
                                     system_ids::VOTE_CAST,
                                     vote_cast,
                                 ),

sink/src/kg/client.rs

@@ -632,7 +632,7 @@ impl Client {
         self.find_nodes::<T>(query).await
     }
 
-    pub async fn value_type_nodes<T: for<'a> Deserialize<'a> + Send>(&self, id: &str) -> Result<Option<Node<T>>, DatabaseError> {
+    pub async fn value_type_node<T: for<'a> Deserialize<'a> + Send>(&self, id: &str) -> Result<Option<Node<T>>, DatabaseError> {
         let query = neo4rs::query(&format!(
             r#"
             MATCH (a {{id: $id}}) -[:`{value_type_attr}`]-> (t:`{type_type}`)
@@ -701,28 +701,3 @@ impl Client {
         Ok(())
     }
 }
-
-#[derive(Debug, Deserialize)]
-pub struct Entity {
-    pub id: String,
-    pub name: Option<String>,
-    pub description: Option<String>,
-    pub cover: Option<String>,
-    pub content: Option<String>,
-}
-
-impl Entity {
-    pub fn new(id: &str, name: &str) -> Self {
-        Self {
-            id: id.to_string(),
-            name: Some(name.to_string()),
-            description: None,
-            cover: None,
-            content: None,
-        }
-    }
-
-    pub fn find_by_id_query(id: &str) -> neo4rs::Query {
-        neo4rs::query("MATCH (n { id: $id }) RETURN n").param("id", id)
-    }
-}

sink/src/kg/mapping.rs

@@ -161,6 +161,10 @@ impl Node<DefaultAttributes> {
             .and_then(|v| v.as_str())
             .map(|s| s.to_string())
     }
+
+    pub fn name_or_id(&self) -> String {
+        self.name().unwrap_or_else(|| self.id().to_string())
+    }
 }
 
 pub type DefaultAttributes = HashMap<String, serde_json::Value>;

sink/src/kg/mod.rs

@@ -1,5 +1,4 @@
 pub mod client;
-pub mod entity;
 pub mod mapping;
 
 pub use client::Client;