feat(torii-core): store update member

bin/torii/src/main.rs

@@ -33,6 +33,7 @@
 use torii_core::processors::store_del_record::StoreDelRecordProcessor;
 use torii_core::processors::store_set_record::StoreSetRecordProcessor;
 use torii_core::processors::store_transaction::StoreTransactionProcessor;
+use torii_core::processors::store_update_member::StoreUpdateMemberProcessor;
 use torii_core::processors::store_update_record::StoreUpdateRecordProcessor;
 use torii_core::simple_broker::SimpleBroker;
 use torii_core::sql::Sql;
@@ -172,6 +173,7 @@
             Box::new(StoreDelRecordProcessor),
             Box::new(EventMessageProcessor),
             Box::new(StoreUpdateRecordProcessor),
+            Box::new(StoreUpdateMemberProcessor),
         ],
         transaction: vec![Box::new(StoreTransactionProcessor)],
         ..Processors::default()

crates/torii/core/src/processors/mod.rs

@@ -12,6 +12,7 @@ pub mod register_model;
 pub mod store_del_record;
 pub mod store_set_record;
 pub mod store_transaction;
+pub mod store_update_member;
 pub mod store_update_record;
 
 const MODEL_INDEX: usize = 0;

crates/torii/core/src/processors/store_update_member.rs

@@ -0,0 +1,99 @@
+use anyhow::{Context, Error, Result};
+use async_trait::async_trait;
+use dojo_world::contracts::model::ModelReader;
+use dojo_world::contracts::naming;
+use dojo_world::contracts::world::WorldContractReader;
+use num_traits::ToPrimitive;
+use starknet::core::types::{Event, TransactionReceiptWithBlockInfo};
+use starknet::core::utils::get_selector_from_name;
+use starknet::providers::Provider;
+use tracing::info;
+
+use super::EventProcessor;
+use crate::processors::{ENTITY_ID_INDEX, MODEL_INDEX};
+use crate::sql::Sql;
+
+pub(crate) const LOG_TARGET: &str = "torii_core::processors::store_update_record";
+
+const MEMBER_INDEX: usize = 2;
+
+#[derive(Default, Debug)]
+pub struct StoreUpdateMemberProcessor;
+
+#[async_trait]
+impl<P> EventProcessor<P> for StoreUpdateMemberProcessor
+where
+    P: Provider + Send + Sync + std::fmt::Debug,
+{
+    fn event_key(&self) -> String {
+        "StoreUpdateMember".to_string()
+    }
+
+    fn validate(&self, event: &Event) -> bool {
+        if event.keys.len() > 1 {
+            info!(
+                target: LOG_TARGET,
+                event_key = %<StoreUpdateMemberProcessor as EventProcessor<P>>::event_key(self),
+                invalid_keys = %<StoreUpdateMemberProcessor as EventProcessor<P>>::event_keys_as_string(self, event),
+                "Invalid event keys."
+            );
+            return false;
+        }
+        true
+    }
+
+    async fn process(
+        &self,
+        _world: &WorldContractReader<P>,
+        db: &mut Sql,
+        _block_number: u64,
+        block_timestamp: u64,
+        _transaction_receipt: &TransactionReceiptWithBlockInfo,
+        _event_id: &str,
+        event: &Event,
+    ) -> Result<(), Error> {
+        let selector = event.data[MODEL_INDEX];
+        let entity_id = event.data[ENTITY_ID_INDEX];
+        let member_selector = event.data[MEMBER_INDEX];
+
+        let model = db.model(selector).await?;
+
+        info!(
+            target: LOG_TARGET,
+            name = %model.name(),
+            entity_id = format!("{:#x}", entity_id),
+            "Store update record.",
+        );
+
+        let values_start = MEMBER_INDEX + 1;
+        let values_end: usize =
+            values_start + event.data[values_start].to_usize().context("invalid usize")?;
+
+        // Skip the length to only get the values as they will be deserialized.
+        let values = event.data[values_start + 1..=values_end].to_vec();
+
+        let tag = naming::get_tag(model.namespace(), model.name());
+
+        // Keys are read from the db, since we don't have access to them when only
+        // the entity id is passed.
+        let keys = db.get_entity_keys(entity_id, &tag).await?;
+        let mut keys_and_unpacked = [keys, values].concat();
+
+        let schema = model.schema().await?;
+        let mut ty = schema
+            .as_struct()
+            .expect("model schema must be a struct")
+            .children
+            .iter()
+            .find(|c| {
+                get_selector_from_name(&c.name).expect("invalid selector for member name")
+                    == member_selector
+            })
+            .context("member not found")?
+            .ty
+            .clone();
+        ty.deserialize(&mut keys_and_unpacked)?;
+
+        db.set_model_member(entity_id, &schema.name(), &ty, block_timestamp).await
+    }
+}

crates/torii/core/src/sql.rs

@@ -271,6 +271,29 @@
         Ok(())
     }
 
+    pub async fn set_model_member(
+        &mut self,
+        entity_id: Felt,
+        model_tag: &str,
+        member: &Ty,
+        block_timestamp: u64,
+    ) -> Result<()> {
+        let entity_id = format!("{:#x}", entity_id);
+        let path = vec![model_tag.to_string()];
+        // update model member
+        self.build_set_entity_queries_recursive(
+            path,
+            &entity_id,
+            (&entity_id, false),
+            member,
+            block_timestamp,
+            &vec![],
+        );
+        self.query_queue.execute_all().await?;
+
+        Ok(())
+    }
+
     pub async fn delete_entity(&mut self, entity_id: Felt, entity: Ty) -> Result<()> {
         let entity_id = format!("{:#x}", entity_id);
         let path = vec![entity.name()];
@@ -556,7 +579,7 @@
         }
     }
 
-    fn build_set_entity_queries_recursive(
+    pub fn build_set_entity_queries_recursive(
         &mut self,
         path: Vec<String>,
         event_id: &str,