refactor(queries): Remove even more singular queries (#5261)

* feat(queries): allow query projections to work on metadata values via dynamic keys
* refactor(queries): replace uses of FindAccountMetadata with projected FindAccounts
* feat(queries): add a prototype of trigger action, exposing trigger metadata to projections
* refactor(queries): replace uses of FindTriggerMetadata with projected FindTriggers
* feat(queries): add projections and predicates for numeric and store `AssetValue`s
* refactor(queries): replace uses of `FindAssetQuantityById` and `FindAssetMetadata` with projected `FindAssets`
* refactor(queries): remove now unused singular queries

---------

Signed-off-by: ⭐️NINIKA⭐️ <[email protected]>

crates/iroha/tests/asset.rs

@@ -284,7 +284,10 @@ fn find_rate_and_make_exchange_isi_should_succeed() {
 
     let assert_balance = |asset_id: AssetId, expected: Numeric| {
         let got = test_client
-            .query_single(FindAssetQuantityById::new(asset_id))
+            .query(FindAssets)
+            .filter_with(|asset| asset.id.eq(asset_id))
+            .select_with(|asset| asset.value.numeric)
+            .execute_single()
             .expect("query should succeed");
         assert_eq!(got, expected);
     };
@@ -293,7 +296,10 @@ fn find_rate_and_make_exchange_isi_should_succeed() {
     assert_balance(buyer_eth.clone(), numeric!(200));
 
     let rate: u32 = test_client
-        .query_single(FindAssetQuantityById::new(rate))
+        .query(FindAssets)
+        .filter_with(|asset| asset.id.eq(rate))
+        .select_with(|asset| asset.value.numeric)
+        .execute_single()
         .expect("query should succeed")
         .try_into()
         .expect("numeric should be u32 originally");
@@ -306,7 +312,10 @@ fn find_rate_and_make_exchange_isi_should_succeed() {
 
     let assert_purged = |asset_id: AssetId| {
         let _err = test_client
-            .query_single(FindAssetQuantityById::new(asset_id))
+            .query(FindAssets)
+            .filter_with(|asset| asset.id.eq(asset_id))
+            .select_with(|asset| asset.value.numeric)
+            .execute_single()
             .expect_err("query should fail, as zero assets are purged from accounts");
     };
     let seller_eth: AssetId = format!("eth#crypto#{}", &seller_id)

crates/iroha/tests/multisig.rs

@@ -249,10 +249,10 @@ fn multisig_base(suite: TestSuite) -> Result<()> {
 
     // Check that the multisig transaction has not yet executed
     let _err = test_client
-        .query_single(FindAccountMetadata::new(
-            transaction_target.clone(),
-            key.clone(),
-        ))
+        .query(FindAccounts)
+        .filter_with(|account| account.id.eq(transaction_target.clone()))
+        .select_with(|account| account.metadata.key(key.clone()))
+        .execute_single()
         .expect_err("instructions shouldn't execute without enough approvals");
 
     // The last approve to proceed to validate and execute the instructions
@@ -268,7 +268,11 @@ fn multisig_base(suite: TestSuite) -> Result<()> {
     }
 
     // Check if the multisig transaction has executed
-    let res = test_client.query_single(FindAccountMetadata::new(transaction_target, key.clone()));
+    let res = test_client
+        .query(FindAccounts)
+        .filter_with(|account| account.id.eq(transaction_target.clone()))
+        .select_with(|account| account.metadata.key(key.clone()))
+        .execute_single();
     match (&transaction_ttl_ms_opt, &unauthorized_target_opt) {
         (None, None) => {
             res.unwrap();
@@ -279,12 +283,17 @@ fn multisig_base(suite: TestSuite) -> Result<()> {
     }
 
     // Check if the transaction entry is deleted
-    let res = test_client.query_single(FindAccountMetadata::new(
-        multisig_account_id,
-        format!("multisig/proposals/{instructions_hash}")
-            .parse()
-            .unwrap(),
-    ));
+    let res = test_client
+        .query(FindAccounts)
+        .filter_with(|account| account.id.eq(multisig_account_id))
+        .select_with(|account| {
+            account.metadata.key(
+                format!("multisig/proposals/{instructions_hash}")
+                    .parse()
+                    .unwrap(),
+            )
+        })
+        .execute_single();
     match (&transaction_ttl_ms_opt, &unauthorized_target_opt) {
         (None, Some(_)) => {
             // In case failing validation, the entry can exit only by expiring
@@ -407,10 +416,14 @@ fn multisig_recursion_base(suite: TestSuite) -> Result<()> {
 
     let proposal_value_at = |msa: AccountId, mst_hash: HashOf<Vec<InstructionBox>>| {
         test_client
-            .query_single(FindAccountMetadata::new(
-                msa.clone(),
-                format!("multisig/proposals/{mst_hash}").parse().unwrap(),
-            ))
+            .query(FindAccounts)
+            .filter_with(|account| account.id.eq(msa.clone()))
+            .select_with(|account| {
+                account
+                    .metadata
+                    .key(format!("multisig/proposals/{mst_hash}").parse().unwrap())
+            })
+            .execute_single()
             .expect("should be initialized by the root proposal")
             .try_into_any::<MultisigProposalValue>()
             .unwrap()
@@ -457,10 +470,10 @@ fn multisig_recursion_base(suite: TestSuite) -> Result<()> {
 
     // Check that the multisig transaction has not yet executed
     let _err = test_client
-        .query_single(FindAccountMetadata::new(
-            transaction_target.clone(),
-            key.clone(),
-        ))
+        .query(FindAccounts)
+        .filter_with(|account| account.id.eq(transaction_target.clone()))
+        .select_with(|account| account.metadata.key(key.clone()))
+        .execute_single()
         .expect_err("instructions shouldn't execute without enough approvals");
 
     // The last approve to proceed to validate and execute the instructions
@@ -476,7 +489,11 @@ fn multisig_recursion_base(suite: TestSuite) -> Result<()> {
     }
 
     // Check if the multisig transaction has executed
-    let res = test_client.query_single(FindAccountMetadata::new(transaction_target, key.clone()));
+    let res = test_client
+        .query(FindAccounts)
+        .filter_with(|account| account.id.eq(transaction_target))
+        .select_with(|account| account.metadata.key(key.clone()))
+        .execute_single();
     match (&transaction_ttl_ms_opt, &unauthorized_target_opt) {
         (None, None) => {
             res.unwrap();
@@ -493,10 +510,15 @@ fn multisig_recursion_base(suite: TestSuite) -> Result<()> {
         (msa_12345, approval_hash_to_012345),
         (msa_012345, instructions_hash),
     ] {
-        let res = test_client.query_single(FindAccountMetadata::new(
-            msa,
-            format!("multisig/proposals/{mst_hash}").parse().unwrap(),
-        ));
+        let res = test_client
+            .query(FindAccounts)
+            .filter_with(|account| account.id.eq(msa))
+            .select_with(|account| {
+                account
+                    .metadata
+                    .key(format!("multisig/proposals/{mst_hash}").parse().unwrap())
+            })
+            .execute_single();
         match (&transaction_ttl_ms_opt, &unauthorized_target_opt) {
             (None, Some(_)) => {
                 // In case the root proposal is failing validation, the relevant entries can exit only by expiring

crates/iroha/tests/queries/metadata.rs

@@ -0,0 +1,89 @@
+use std::{collections::BTreeMap, str::FromStr};
+
+use iroha::{client::QueryError, data_model::prelude::*};
+use iroha_data_model::query::{
+    builder::SingleQueryError,
+    error::{FindError, QueryExecutionFail},
+};
+use iroha_test_network::*;
+use iroha_test_samples::{ALICE_ID, BOB_ID};
+use serde_json::json;
+
+#[test]
+fn find_accounts_with_asset() {
+    let (network, _rt) = NetworkBuilder::new().start_blocking().unwrap();
+    let test_client = network.client();
+
+    let key = Name::from_str("key").unwrap();
+    let another_key = Name::from_str("another_key").unwrap();
+
+    test_client
+        .submit_blocking(SetKeyValue::account(
+            BOB_ID.clone(),
+            key.clone(),
+            json!({"funny": "value"}),
+        ))
+        .unwrap();
+    test_client
+        .submit_blocking(SetKeyValue::account(
+            BOB_ID.clone(),
+            another_key.clone(),
+            "value",
+        ))
+        .unwrap();
+
+    // we have the following configuration:
+    //          key                 another_key
+    // ALICE    "value"             -
+    // BOB      {"funny": "value"}  "value"
+
+    // check that bulk retrieval works as expected
+    let key_values = test_client
+        .query(FindAccounts)
+        .filter_with(|account| account.id.eq(ALICE_ID.clone()) | account.id.eq(BOB_ID.clone()))
+        .select_with(|account| (account.id, account.metadata.key(key.clone())))
+        .execute_all()
+        .unwrap()
+        .into_iter()
+        .collect::<BTreeMap<_, _>>();
+
+    assert_eq!(key_values.len(), 2);
+    assert_eq!(key_values[&ALICE_ID], "value".into());
+    assert_eq!(key_values[&BOB_ID], json!({"funny": "value"}).into());
+
+    // check that missing metadata key produces an error
+    let alice_no_key_err = test_client
+        .query(FindAccounts)
+        .filter_with(|account| account.id.eq(ALICE_ID.clone()))
+        .select_with(|account| account.metadata.key(another_key.clone()))
+        .execute_single()
+        .unwrap_err();
+
+    let SingleQueryError::QueryError(QueryError::Validation(ValidationFail::QueryFailed(
+        QueryExecutionFail::Find(FindError::MetadataKey(returned_key)),
+    ))) = alice_no_key_err
+    else {
+        panic!("Got unexpected query error on missing metadata key {alice_no_key_err:?}",);
+    };
+    assert_eq!(returned_key, another_key);
+
+    // check single key retrieval
+    let another_key_value = test_client
+        .query(FindAccounts)
+        .filter_with(|account| account.id.eq(BOB_ID.clone()))
+        .select_with(|account| account.metadata.key(another_key.clone()))
+        .execute_single()
+        .unwrap();
+    assert_eq!(another_key_value, "value".into());
+
+    // check predicates on non-existing metadata (they should just evaluate to false)
+    let accounts = test_client
+        .query(FindAccounts)
+        .filter_with(|account| account.metadata.key(another_key.clone()).eq("value".into()))
+        .select_with(|account| account.id)
+        .execute_all()
+        .unwrap();
+
+    assert_eq!(accounts.len(), 1);
+    assert_eq!(accounts[0], BOB_ID.clone());
+}

crates/iroha/tests/queries/mod.rs

@@ -9,6 +9,7 @@ use iroha_test_network::*;
 
 mod account;
 mod asset;
+mod metadata;
 mod query_errors;
 mod role;
 mod smart_contract;

crates/iroha/tests/queries/smart_contract.rs

@@ -17,10 +17,12 @@ fn live_query_is_dropped_after_smart_contract_end() -> Result<()> {
     );
     client.submit_transaction_blocking(&transaction)?;
 
-    let metadata_value: Json = client.query_single(FindAccountMetadata::new(
-        client.account.clone(),
-        "cursor".parse().unwrap(),
-    ))?;
+    let metadata_value = client
+        .query(FindAccounts)
+        .filter_with(|account| account.id.eq(client.account.clone()))
+        .select_with(|account| account.metadata.key("cursor".parse().unwrap()))
+        .execute_single()?;
+
     let asset_cursor = metadata_value.try_into_any()?;
 
     // here we are breaking the abstraction preventing us from using a cursor we pulled from the metadata

crates/iroha/tests/triggers/time_trigger.rs

@@ -40,7 +40,11 @@ fn mint_asset_after_3_sec() -> Result<()> {
     let account_id = ALICE_ID.clone();
     let asset_id = AssetId::new(asset_definition_id.clone(), account_id.clone());
 
-    let init_quantity = test_client.query_single(FindAssetQuantityById::new(asset_id.clone()))?;
+    let init_quantity = test_client
+        .query(FindAssets)
+        .filter_with(|asset| asset.id.eq(asset_id.clone()))
+        .select_with(|asset| asset.value.numeric)
+        .execute_single()?;
 
     let start_time = curr_time();
     assert!(
@@ -62,16 +66,22 @@ fn mint_asset_after_3_sec() -> Result<()> {
 
     // Schedule start is in the future so trigger isn't executed after creating a new block
     test_client.submit_blocking(Log::new(Level::DEBUG, "Just to create block".to_string()))?;
-    let after_registration_quantity =
-        test_client.query_single(FindAssetQuantityById::new(asset_id.clone()))?;
+    let after_registration_quantity = test_client
+        .query(FindAssets)
+        .filter_with(|asset| asset.id.eq(asset_id.clone()))
+        .select_with(|asset| asset.value.numeric)
+        .execute_single()?;
     assert_eq!(init_quantity, after_registration_quantity);
 
     // Sleep long enough that trigger start is in the past
     std::thread::sleep(network.pipeline_time());
     test_client.submit_blocking(Log::new(Level::DEBUG, "Just to create block".to_string()))?;
 
-    let after_wait_quantity =
-        test_client.query_single(FindAssetQuantityById::new(asset_id.clone()))?;
+    let after_wait_quantity = test_client
+        .query(FindAssets)
+        .filter_with(|asset| asset.id.eq(asset_id.clone()))
+        .select_with(|asset| asset.value.numeric)
+        .execute_single()?;
     // Schedule is in the past now so trigger is executed
     assert_eq!(
         init_quantity.checked_add(1u32.into()).unwrap(),

crates/iroha/tests/upgrade.rs

@@ -1,4 +1,4 @@
-use executor_custom_data_model::permissions::CanControlDomainLives;
+use executor_custom_data_model::{complex_isi::NumericQuery, permissions::CanControlDomainLives};
 use eyre::Result;
 use futures_util::TryStreamExt as _;
 use iroha::{
@@ -216,7 +216,11 @@ fn executor_custom_instructions_simple() -> Result<()> {
 
     // Check that bob has 1 rose
     assert_eq!(
-        client.query_single(FindAssetQuantityById::new(bob_rose.clone()))?,
+        client
+            .query(FindAssets)
+            .filter_with(|asset| asset.id.eq(bob_rose.clone()))
+            .select_with(|asset| asset.value.numeric)
+            .execute_single()?,
         Numeric::from(1u32)
     );
 
@@ -229,7 +233,11 @@ fn executor_custom_instructions_simple() -> Result<()> {
 
     // Check that bob has 2 roses
     assert_eq!(
-        client.query_single(FindAssetQuantityById::new(bob_rose.clone()))?,
+        client
+            .query(FindAssets)
+            .filter_with(|asset| asset.id.eq(bob_rose))
+            .select_with(|asset| asset.value.numeric)
+            .execute_single()?,
         Numeric::from(2u32)
     );
 
@@ -258,16 +266,20 @@ fn executor_custom_instructions_complex() -> Result<()> {
 
     // Check that bob has 6 roses
     assert_eq!(
-        client.query_single(FindAssetQuantityById::new(bob_rose.clone()))?,
+        client
+            .query(FindAssets)
+            .filter_with(|asset| asset.id.eq(bob_rose.clone()))
+            .select_with(|asset| asset.value.numeric)
+            .execute_single()?,
         Numeric::from(6u32)
     );
 
     // If bob has more then 5 roses, then burn 1 rose
     let burn_bob_rose_if_more_then_5 = || -> Result<()> {
         let condition = Greater::new(
-            EvaluatesTo::new_unchecked(Expression::Query(
-                FindAssetQuantityById::new(bob_rose.clone()).into(),
-            )),
+            EvaluatesTo::new_unchecked(Expression::Query(NumericQuery::FindAssetQuantityById(
+                bob_rose.clone(),
+            ))),
             Numeric::from(5u32),
         );
         let then = Burn::asset_numeric(Numeric::from(1u32), bob_rose.clone());
@@ -281,15 +293,23 @@ fn executor_custom_instructions_complex() -> Result<()> {
 
     // Check that bob has 5 roses
     assert_eq!(
-        client.query_single(FindAssetQuantityById::new(bob_rose.clone()))?,
+        client
+            .query(FindAssets)
+            .filter_with(|asset| asset.id.eq(bob_rose.clone()))
+            .select_with(|asset| asset.value.numeric)
+            .execute_single()?,
         Numeric::from(5u32)
     );
 
     burn_bob_rose_if_more_then_5()?;
 
     // Check that bob has 5 roses
     assert_eq!(
-        client.query_single(FindAssetQuantityById::new(bob_rose.clone()))?,
+        client
+            .query(FindAssets)
+            .filter_with(|asset| asset.id.eq(bob_rose.clone()))
+            .select_with(|asset| asset.value.numeric)
+            .execute_single()?,
         Numeric::from(5u32)
     );