refactor(torii-grpc): use Option for felt as keys wildcard (#2119)

* refactor: use Option for felt as wildcard * reduce code footprint * clippy😡 * fmt🤬
dojoengine · Jun 28, 2024 · ed0c677 · ed0c677
1 parent 6193f22
commit ed0c677
Show file tree

Hide file tree

Showing 4 changed files with 28 additions and 31 deletions.
diff --git a/crates/torii/grpc/src/server/subscriptions/entity.rs b/crates/torii/grpc/src/server/subscriptions/entity.rs
@@ -138,17 +138,14 @@ impl Service {
                         let sub_key = clause.keys.get(idx);
 
                         match sub_key {
-                            Some(sub_key) => {
-                                if sub_key == &FieldElement::ZERO {
-                                    true
-                                } else {
-                                    key == sub_key
-                                }
-                            }
-                            // we overflowed the subscriber key pattern
+                            // the key in the subscriber must match the key of the entity
+                            // athis index
+                            Some(Some(sub_key)) => key == sub_key,
+                            // otherwise, if we have no key we should automatically match.
+                            // or.. we overflowed the subscriber key pattern
                             // but we're in VariableLen pattern matching
                             // so we should match all next keys
-                            None => true,
+                            _ => true,
                         }
                     }) {
                         continue;

diff --git a/crates/torii/grpc/src/server/subscriptions/event.rs b/crates/torii/grpc/src/server/subscriptions/event.rs
@@ -104,17 +104,14 @@ impl Service {
                 // if we have a key in the subscriber, it must match the key in the event
                 // unless its empty, which is a wildcard
                 match sub_key {
-                    Some(sub_key) => {
-                        if sub_key == &FieldElement::ZERO {
-                            true
-                        } else {
-                            key == sub_key
-                        }
-                    }
-                    // we overflowed the subscriber key pattern
+                    // the key in the subscriber must match the key of the entity
+                    // athis index
+                    Some(Some(sub_key)) => key == sub_key,
+                    // otherwise, if we have no key we should automatically match.
+                    // or.. we overflowed the subscriber key pattern
                     // but we're in VariableLen pattern matching
                     // so we should match all next keys
-                    None => true,
+                    _ => true,
                 }
             }) {
                 continue;

diff --git a/crates/torii/grpc/src/server/subscriptions/event_message.rs b/crates/torii/grpc/src/server/subscriptions/event_message.rs
@@ -137,17 +137,14 @@ impl Service {
                         let sub_key = clause.keys.get(idx);
 
                         match sub_key {
-                            Some(sub_key) => {
-                                if sub_key == &FieldElement::ZERO {
-                                    true
-                                } else {
-                                    key == sub_key
-                                }
-                            }
-                            // we overflowed the subscriber key pattern
+                            // the key in the subscriber must match the key of the entity
+                            // athis index
+                            Some(Some(sub_key)) => key == sub_key,
+                            // otherwise, if we have no key we should automatically match.
+                            // or.. we overflowed the subscriber key pattern
                             // but we're in VariableLen pattern matching
                             // so we should match all next keys
-                            None => true,
+                            _ => true,
                         }
                     }) {
                         continue;

diff --git a/crates/torii/grpc/src/types/mod.rs b/crates/torii/grpc/src/types/mod.rs
@@ -43,7 +43,7 @@ pub struct ModelKeysClause {
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Hash, Eq, Clone)]
 pub struct KeysClause {
-    pub keys: Vec<FieldElement>,
+    pub keys: Vec<Option<FieldElement>>,
     pub pattern_matching: PatternMatching,
     pub models: Vec<String>,
 }
@@ -184,7 +184,11 @@ impl From<proto::types::PatternMatching> for PatternMatching {
 impl From<KeysClause> for proto::types::KeysClause {
     fn from(value: KeysClause) -> Self {
         Self {
-            keys: value.keys.iter().map(|k| k.to_bytes_be().into()).collect(),
+            keys: value
+                .keys
+                .iter()
+                .map(|k| k.map_or(Vec::new(), |k| k.to_bytes_be().into()))
+                .collect(),
             pattern_matching: value.pattern_matching as i32,
             models: value.models,
         }
@@ -198,8 +202,10 @@ impl TryFrom<proto::types::KeysClause> for KeysClause {
         let keys = value
             .keys
             .iter()
-            .map(|k| FieldElement::from_byte_slice_be(k))
-            .collect::<Result<Vec<_>, _>>()?;
+            .map(|k| {
+                if k.is_empty() { Ok(None) } else { Ok(Some(FieldElement::from_byte_slice_be(k)?)) }
+            })
+            .collect::<Result<Vec<Option<FieldElement>>, _>>()?;
 
         Ok(Self { keys, pattern_matching: value.pattern_matching().into(), models: value.models })
     }