graph,runtime,store: fix requested changes

Author: gusinacio

graph/src/components/store/entity_cache.rs

@@ -119,11 +119,11 @@ impl EntityCache {
         &mut self,
         eref: &LoadRelatedRequest,
     ) -> Result<Vec<Entity>, anyhow::Error> {
-        let (base_type, field) = self.schema.get_type_for_field(eref)?;
+        let (base_type, field) = self.schema.get_field_related(eref)?;
 
         let query = DerivedEntityQuery {
             entity_type: EntityType::new(base_type.to_string()),
-            entity_field: field.into(),
+            entity_field: field.name.clone().into(),
             value: eref.entity_id.clone(),
             causality_region: eref.causality_region,
         };

graph/src/data/schema.rs

@@ -539,7 +539,22 @@ impl Schema {
         }
     }
 
-    pub fn get_type_for_field(&self, key: &LoadRelatedRequest) -> Result<(&str, &str), Error> {
+    /// Returns the field that has the relationship with the key requested
+    /// This works as a reverse search for the Field related to the query
+    ///
+    /// example:
+    ///
+    /// type Account @entity {
+    ///     wallets: [Wallet!]! @derivedFrom("account")
+    /// }
+    /// type Wallet {
+    ///     account: Account!
+    ///     balance: Int!
+    /// }
+    ///
+    /// When asked to load the related entities from "Account" in the field "wallets"
+    /// This function will return the type "Wallet" with the field "account"
+    pub fn get_field_related(&self, key: &LoadRelatedRequest) -> Result<(&str, &Field), Error> {
         let field = self
             .document
             .get_object_type_definition(key.entity_type.as_str())
@@ -561,11 +576,32 @@ impl Schema {
                 )
             })?;
         if field.is_derived() {
-            let derived_from = field.find_directive("derivedFrom").unwrap();
+            let derived_from = field.find_directive("derivedfrom").unwrap();
             let base_type = field.field_type.get_base_type();
-            let field = derived_from.argument("field").unwrap();
+            let field_name = derived_from.argument("field").unwrap();
+
+            let field = self
+                .document
+                .get_object_type_definition(base_type)
+                .ok_or_else(|| {
+                    anyhow!(
+                        "Entity {}[{}]: unknown entity type `{}`",
+                        key.entity_type,
+                        key.entity_id,
+                        key.entity_type,
+                    )
+                })?
+                .field(field_name.as_str().unwrap())
+                .ok_or_else(|| {
+                    anyhow!(
+                        "Entity {}[{}]: unknown field `{}`",
+                        key.entity_type,
+                        key.entity_id,
+                        key.entity_field,
+                    )
+                })?;
 
-            Ok((base_type, field.as_str().unwrap()))
+            Ok((base_type, field))
         } else {
             Err(anyhow!(
                 "Entity {}[{}]: field `{}` is not derived",

runtime/wasm/src/module/mod.rs

@@ -530,7 +530,7 @@ impl<C: Blockchain> WasmInstance<C> {
         link!(
             "store.loadRelated",
             store_load_related,
-            "host_export_store_get_derived",
+            "host_export_store_load_related",
             entity,
             id,
             field
@@ -1086,10 +1086,8 @@ impl<C: Blockchain> WasmInstanceContext<C> {
             gas,
         )?;
 
-        let entities: Vec<Vec<(String, Value)>> = entities
-            .iter()
-            .map(|entity| entity.clone().sorted())
-            .collect();
+        let entities: Vec<Vec<(String, Value)>> =
+            entities.into_iter().map(|entity| entity.sorted()).collect();
         let ret = asc_new(self, &entities, gas)?;
         Ok(ret)
     }

store/postgres/src/deployment_store.rs

@@ -1124,7 +1124,7 @@ impl DeploymentStore {
         site: Arc<Site>,
         derived_query: &DerivedEntityQuery,
         block: BlockNumber,
-        excluded_keys: &Option<Vec<EntityKey>>,
+        excluded_keys: &Vec<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         let conn = self.get_conn()?;
         let layout = self.layout(&conn, site)?;

store/postgres/src/relational.rs

@@ -563,7 +563,7 @@ impl Layout {
         conn: &PgConnection,
         derived_query: &DerivedEntityQuery,
         block: BlockNumber,
-        excluded_keys: &Option<Vec<EntityKey>>,
+        excluded_keys: &Vec<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         let table = self.table_for_entity(&derived_query.entity_type)?;
         let query = FindDerivedQuery::new(table, derived_query, block, excluded_keys);

store/postgres/src/relational_queries.rs

@@ -1675,7 +1675,7 @@ pub struct FindDerivedQuery<'a> {
     table: &'a Table,
     derived_query: &'a DerivedEntityQuery,
     block: BlockNumber,
-    excluded_keys: &'a Option<Vec<EntityKey>>,
+    excluded_keys: &'a Vec<EntityKey>,
 }
 
 impl<'a> QueryFragment<Pg> for FindDerivedQuery<'a> {
@@ -1699,11 +1699,11 @@ impl<'a> QueryFragment<Pg> for FindDerivedQuery<'a> {
         out.push_sql(self.table.qualified_name.as_str());
         out.push_sql(" e\n where ");
 
-        if let Some(keys) = self.excluded_keys.as_ref().filter(|keys| keys.len() > 0) {
+        if self.excluded_keys.len() > 0 {
             let primary_key = self.table.primary_key();
             out.push_identifier(primary_key.name.as_str())?;
             out.push_sql(" not in (");
-            for (i, value) in keys.iter().enumerate() {
+            for (i, value) in self.excluded_keys.iter().enumerate() {
                 if i > 0 {
                     out.push_sql(", ");
                 }

store/postgres/src/writable.rs

@@ -254,7 +254,7 @@ impl SyncStore {
         &self,
         key: &DerivedEntityQuery,
         block: BlockNumber,
-        excluded_keys: Option<Vec<EntityKey>>,
+        excluded_keys: Vec<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         self.retry("get_derived", || {
             self.writable
@@ -776,7 +776,9 @@ impl Queue {
                             for emod in mods {
                                 let key = emod.entity_ref();
                                 // we select just the entities that match the query
-                                if derived_query.entity_type == key.entity_type {
+                                if derived_query.entity_type == key.entity_type
+                                    && derived_query.value == key.entity_id
+                                {
                                     map.insert(key.clone(), emod.entity().cloned());
                                 }
                             }
@@ -793,7 +795,7 @@ impl Queue {
         // We filter to exclude the entities ids that we already have from the queue
         let mut items_from_database =
             self.store
-                .get_derived(derived_query, tracker.query_block(), Some(excluded_keys))?;
+                .get_derived(derived_query, tracker.query_block(), excluded_keys)?;
 
         // Extend the store results with the entities from the queue.
         // This overwrites any entitiy from the database with the same key from queue
@@ -969,7 +971,7 @@ impl Writer {
         key: &DerivedEntityQuery,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         match self {
-            Writer::Sync(store) => store.get_derived(key, BLOCK_NUMBER_MAX, None),
+            Writer::Sync(store) => store.get_derived(key, BLOCK_NUMBER_MAX, vec![]),
             Writer::Async(queue) => queue.get_derived(key),
         }
     }