Test custom query

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
       - name: Install Rust
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.66.0
+          toolchain: 1.70.0
           target: wasm32-unknown-unknown
           profile: minimal
           override: true
@@ -87,6 +87,9 @@ jobs:
       - name: Build entry-points-overriding
         working-directory: examples/contracts/entry-points-overriding
         run: cargo build --release --target wasm32-unknown-unknown --locked --lib
+      - name: Build custom
+        working-directory: examples/contracts/custom
+        run: cargo build --release --target wasm32-unknown-unknown --locked --lib
       - name: Install cosmwasm-check
         run: cargo install cosmwasm-check --force
       - name: Check contracts
@@ -103,6 +106,9 @@ jobs:
       - name: Entry-points-overriding schema
         working-directory: examples/contracts/entry-points-overriding
         run: cargo schema
+      - name: Custom schema
+        working-directory: examples/contracts/custom
+        run: cargo schema
       - name: Cw1-whitelist ts-codegen 
         working-directory: examples/contracts/cw1-whitelist/
         run: cosmwasm-ts-codegen generate --plugin client --schema ./schema --out ./ts --name cw1-whitelist --no-bundle
@@ -115,6 +121,9 @@ jobs:
       - name: Entry-points-overriding ts-codegen
         working-directory: examples/contracts/entry-points-overriding
         run: cosmwasm-ts-codegen generate --plugin client --schema ./schema --out ./ts --name entry-points-overriding --no-bundle
+      - name: Custom ts-codegen
+        working-directory: examples/contracts/custom/
+        run: cosmwasm-ts-codegen generate --plugin client --schema ./schema --out ./ts --name custom --no-bundle
       - name: Archive schema artifats
         uses: actions/upload-artifact@v3
         with:
@@ -124,6 +133,7 @@ jobs:
             examples/contracts/cw1-whitelist/schema/cw1-whitelist.json
             examples/contracts/cw20-base/schema/cw20-base.json
             examples/contracts/entry-points-overriding/schema/entry-points-overriding.json
+            examples/contracts/custom/schema/custom.json
 
   coverage:
     name: Code coverage
@@ -146,7 +156,7 @@ jobs:
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
       - name:                   Generate code coverage
         run: |
-          cargo tarpaulin --verbose --all-features --workspace --timeout 120 --out Xml --engine llvm
+          cargo tarpaulin --verbose --all-features --workspace --timeout 120 --out xml --engine llvm
       - name:                   Upload to codecov.io
         uses:                   codecov/codecov-action@v2
         with:

examples/Cargo.toml

@@ -12,6 +12,7 @@ members = [
   "contracts/cw1-subkeys",
   "contracts/cw20-base",
   "contracts/entry-points-overriding",
+  "contracts/custom",
 ]
 resolver = "2"
 

examples/contracts/custom/.cargo/config

@@ -0,0 +1,6 @@
+[alias]
+wasm = "build --release --target wasm32-unknown-unknown --lib"
+wasm-debug = "build --target wasm32-unknown-unknown --lib"
+unit-test = "test --lib"
+integration-test = "test --test integration"
+schema = "run --bin schema"

examples/contracts/custom/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "custom"
+version = { workspace = true }
+authors = ["Jan Woźniak <[email protected]>"]
+edition = { workspace = true }
+description = "Example of custom message usage."
+license = "Apache-2.0"
+repository = "https://github.com/CosmWasm/sylvia"
+homepage = "https://cosmwasm.com"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+library = []
+mt = ["library"]
+
+[dependencies]
+cosmwasm-schema = "1.2"
+cosmwasm-std = { version = "1.3", features = ["staking"] }
+cw-storage-plus = "1.0"
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+sylvia = { path = "../../../sylvia" }
+
+[dev-dependencies]
+anyhow = "1.0"
+cw-multi-test = "0.16"
+sylvia = { path = "../../../sylvia", features = ["mt"] }

examples/contracts/custom/src/bin/schema.rs

@@ -0,0 +1,12 @@
+use cosmwasm_schema::write_api;
+
+use custom::contract::{ContractExecMsg, ContractQueryMsg, InstantiateMsg};
+
+#[cfg(not(tarpaulin_include))]
+fn main() {
+    write_api! {
+        instantiate: InstantiateMsg,
+        execute: ContractExecMsg,
+        query: ContractQueryMsg,
+    }
+}

examples/contracts/custom/src/contract.rs

@@ -0,0 +1,41 @@
+use cosmwasm_std::{CosmosMsg, QueryRequest, Response, StdResult};
+use sylvia::types::{ExecCtx, InstantiateCtx, QueryCtx};
+use sylvia::{contract, entry_points, schemars};
+
+use crate::messages::{CountResponse, CounterMsg, CounterQuery};
+
+pub struct CustomContract;
+
+#[cfg_attr(not(feature = "mt"), entry_points)]
+#[contract]
+#[sv::custom(query=CounterQuery, msg=CounterMsg)]
+impl CustomContract {
+    pub const fn new() -> Self {
+        Self
+    }
+
+    #[msg(instantiate)]
+    pub fn instantiate(
+        &self,
+        _ctx: InstantiateCtx<CounterQuery>,
+    ) -> StdResult<Response<CounterMsg>> {
+        Ok(Response::default())
+    }
+
+    #[msg(exec)]
+    pub fn send_custom(&self, _ctx: ExecCtx<CounterQuery>) -> StdResult<Response<CounterMsg>> {
+        let msg = CosmosMsg::Custom(CounterMsg::Increment {});
+        let resp = Response::default().add_message(msg);
+        Ok(resp)
+    }
+
+    #[msg(query)]
+    pub fn query_custom(&self, ctx: QueryCtx<CounterQuery>) -> StdResult<CountResponse> {
+        let resp = ctx
+            .deps
+            .querier
+            .query::<CountResponse>(&QueryRequest::Custom(CounterQuery::Count {}))?;
+
+        Ok(resp)
+    }
+}

examples/contracts/custom/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod contract;
+pub mod messages;
+#[cfg(any(test, feature = "mt"))]
+pub mod multitest;

examples/contracts/custom/src/messages.rs

@@ -0,0 +1,21 @@
+use cosmwasm_schema::cw_serde;
+use cosmwasm_std::{CustomMsg, CustomQuery};
+
+#[cw_serde]
+pub struct CountResponse {
+    pub count: u64,
+}
+
+#[cw_serde]
+pub enum CounterMsg {
+    Increment {},
+}
+
+#[cw_serde]
+pub enum CounterQuery {
+    Count {},
+}
+
+impl CustomMsg for CounterMsg {}
+
+impl CustomQuery for CounterQuery {}

examples/contracts/custom/src/multitest.rs

@@ -0,0 +1,2 @@
+mod custom_module;
+mod tests;

examples/contracts/custom/src/multitest/custom_module.rs

@@ -0,0 +1,96 @@
+use cosmwasm_schema::schemars::JsonSchema;
+use cosmwasm_std::testing::{MockApi, MockStorage};
+use cosmwasm_std::{
+    to_binary, Addr, Api, Binary, BlockInfo, CustomQuery, Empty, Querier, StdError, StdResult,
+    Storage,
+};
+use cw_multi_test::{AppResponse, BankKeeper, CosmosRouter, Module, WasmKeeper};
+use cw_storage_plus::Item;
+use serde::de::DeserializeOwned;
+use std::fmt::Debug;
+
+use crate::messages::{CountResponse, CounterMsg, CounterQuery};
+
+pub type CustomApp = cw_multi_test::App<
+    BankKeeper,
+    MockApi,
+    MockStorage,
+    CustomModule,
+    WasmKeeper<CounterMsg, CounterQuery>,
+>;
+
+pub struct CustomModule {
+    pub counter: Item<'static, u64>,
+}
+
+impl CustomModule {
+    pub fn new() -> Self {
+        Self {
+            counter: Item::new("counter"),
+        }
+    }
+
+    pub fn save_counter(&self, storage: &mut dyn Storage, value: u64) -> StdResult<()> {
+        self.counter.save(storage, &value)
+    }
+}
+
+impl Module for CustomModule {
+    type ExecT = CounterMsg;
+    type QueryT = CounterQuery;
+    type SudoT = Empty;
+
+    fn execute<ExecC, QueryC>(
+        &self,
+        _api: &dyn Api,
+        storage: &mut dyn Storage,
+        _router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
+        _block: &BlockInfo,
+        _sender: Addr,
+        msg: Self::ExecT,
+    ) -> anyhow::Result<AppResponse>
+    where
+        ExecC: Debug + Clone + PartialEq + JsonSchema + DeserializeOwned + 'static,
+        QueryC: CustomQuery + DeserializeOwned + 'static,
+    {
+        match msg {
+            CounterMsg::Increment {} => {
+                self.counter
+                    .update(storage, |value| Ok::<_, StdError>(value + 1))?;
+                Ok(AppResponse::default())
+            }
+        }
+    }
+
+    fn sudo<ExecC, QueryC>(
+        &self,
+        _api: &dyn Api,
+        _storage: &mut dyn Storage,
+        _router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
+        _block: &BlockInfo,
+        _msg: Self::SudoT,
+    ) -> anyhow::Result<AppResponse>
+    where
+        ExecC: Debug + Clone + PartialEq + JsonSchema + DeserializeOwned + 'static,
+        QueryC: CustomQuery + DeserializeOwned + 'static,
+    {
+        Ok(AppResponse::default())
+    }
+
+    fn query(
+        &self,
+        _api: &dyn Api,
+        storage: &dyn Storage,
+        _querier: &dyn Querier,
+        _block: &BlockInfo,
+        request: Self::QueryT,
+    ) -> anyhow::Result<Binary> {
+        match request {
+            CounterQuery::Count {} => {
+                let count = self.counter.load(storage)?;
+                let res = CountResponse { count };
+                to_binary(&res).map_err(Into::into)
+            }
+        }
+    }
+}

examples/contracts/custom/src/multitest/tests.rs

@@ -0,0 +1,27 @@
+use sylvia::multitest::App;
+
+use crate::contract::multitest_utils::CodeId;
+
+use super::custom_module::{CustomApp, CustomModule};
+
+#[test]
+fn test_custom() {
+    let owner = "owner";
+
+    let mt_app = cw_multi_test::BasicAppBuilder::new_custom()
+        .with_custom(CustomModule::new())
+        .build(|router, _, storage| {
+            router.custom.save_counter(storage, 0).unwrap();
+        });
+
+    let app = App::<CustomApp>::new(mt_app);
+
+    let code_id = CodeId::store_code(&app);
+
+    let contract = code_id.instantiate().call(owner).unwrap();
+
+    contract.send_custom().call(owner).unwrap();
+
+    let count = contract.query_custom().unwrap().count;
+    assert_eq!(count, 1);
+}

sylvia-derive/src/message.rs

@@ -1096,6 +1096,7 @@ impl<'a> EntryPoints<'a> {
         let sylvia = crate_module();
 
         let custom_msg = custom.msg_or_default();
+        let custom_query = custom.query_or_default();
 
         #[cfg(not(tarpaulin_include))]
         {
@@ -1106,6 +1107,7 @@ impl<'a> EntryPoints<'a> {
                         Some(_) => quote! {},
                         None => OverrideEntryPoint::emit_default_entry_point(
                             &custom_msg,
+                            &custom_query,
                             name,
                             error,
                             msg_type,
@@ -1120,7 +1122,7 @@ impl<'a> EntryPoints<'a> {
                     Some(reply) => quote! {
                         #[#sylvia ::cw_std::entry_point]
                         pub fn reply(
-                            deps: #sylvia ::cw_std::DepsMut,
+                            deps: #sylvia ::cw_std::DepsMut< #custom_query >,
                             env: #sylvia ::cw_std::Env,
                             msg: #sylvia ::cw_std::Reply,
                         ) -> Result<#sylvia ::cw_std::Response < #custom_msg >, #error> {

sylvia-derive/src/parser.rs

@@ -83,20 +83,20 @@ impl MsgType {
     }
 
     #[cfg(not(tarpaulin_include))]
-    pub fn emit_ctx_params(self) -> TokenStream {
+    pub fn emit_ctx_params(self, query_type: &Type) -> TokenStream {
         use MsgType::*;
 
         let sylvia = crate_module();
 
         match self {
             Exec | Instantiate => quote! {
-                deps: #sylvia ::cw_std::DepsMut, env: #sylvia ::cw_std::Env, info: #sylvia ::cw_std::MessageInfo
+                deps: #sylvia ::cw_std::DepsMut< #query_type>, env: #sylvia ::cw_std::Env, info: #sylvia ::cw_std::MessageInfo
             },
             Migrate | Reply | Sudo => quote! {
-                deps: #sylvia ::cw_std::DepsMut, env: #sylvia ::cw_std::Env
+                deps: #sylvia ::cw_std::DepsMut< #query_type>, env: #sylvia ::cw_std::Env
             },
             Query => quote! {
-                deps: #sylvia ::cw_std::Deps, env: #sylvia ::cw_std::Env
+                deps: #sylvia ::cw_std::Deps< #query_type>, env: #sylvia ::cw_std::Env
             },
         }
     }
@@ -540,6 +540,7 @@ impl OverrideEntryPoint {
     #[cfg(not(tarpaulin_include))]
     pub fn emit_default_entry_point(
         custom_msg: &Type,
+        custom_query: &Type,
         name: &Type,
         error: &Type,
         msg_type: MsgType,
@@ -550,7 +551,7 @@ impl OverrideEntryPoint {
             MsgType::Query => quote! { #sylvia ::cw_std::Binary },
             _ => quote! { #sylvia ::cw_std::Response < #custom_msg > },
         };
-        let params = msg_type.emit_ctx_params();
+        let params = msg_type.emit_ctx_params(custom_query);
         let values = msg_type.emit_ctx_values();
         let ep_name = msg_type.emit_ep_name();
         let msg_name = msg_type.emit_msg_name();