Merge pull request #1227 from demergent-labs/manual_examples

Manual examples

.github/workflows/test.yml

@@ -83,12 +83,10 @@
 # These are the ones that don't work
 # "examples/tuple_types",
 # "examples/service",
-# "examples/outgoing_http_requests",
 # "examples/robust_imports",
 # "examples/run_time_errors",
 # "examples/rust_type_conversions",
 # "examples/complex_types",
-# "examples/composite_queries",
 # "examples/func_types",
 # "examples/generics",
 # "examples/guard_functions",
@@ -149,6 +147,7 @@ jobs:
                     "examples/candid_encoding",
                     "examples/counter",
                     "examples/complex_init",
+                    "examples/composite_queries",
                     "examples/cross_canister_calls",
                     "examples/cycles",
                     "examples/ethereum_json_rpc",
@@ -180,6 +179,7 @@ jobs:
                     "examples/null_example",
                     "examples/optional_types",
                     "examples/pre_and_post_upgrade",
+                    "examples/outgoing_http_requests",
                     "examples/primitive_types",
                     "examples/principal",
                     "examples/query",

examples/composite_queries/canisters/canister1/index.did

@@ -0,0 +1,12 @@
+service: () -> {
+    simpleCompositeQuery: () -> (text) query;
+    manualQuery: () -> (text) query;
+    totallyManualQuery: () -> (text) query;
+    deepQuery: () -> (text) query;
+    updateQuery: () -> (text) query;
+    simpleQuery: () -> (text) query;
+    simpleUpdate: () -> (text);
+    incCounter: () -> (nat) query;
+    incCanister1: () -> (nat) query;
+    incCanister2: () -> (nat) query;
+}

examples/composite_queries/canisters/canister1/index.ts

@@ -0,0 +1,89 @@
+import { ic, Manual, nat, Principal, query, Service, text, update } from 'azle';
+import Canister2 from '../canister2';
+
+class Canister1 extends Service {
+    canister2 = new Canister2(
+        Principal.fromText(
+            process.env.CANISTER2_PRINCIPAL ??
+                ic.trap('process.env.CANISTER2_PRINCIPAL is undefined')
+        )
+    );
+
+    counter: nat = 0n;
+
+    // Composite query calling a query
+    @query([], text)
+    async simpleCompositeQuery(): Promise<text> {
+        return await ic.call(this.canister2.simpleQuery);
+    }
+
+    // Composite query calling a manual query
+    @query([], text)
+    async manualQuery(): Promise<text> {
+        return await ic.call(this.canister2.manualQuery);
+    }
+
+    // Manual composite query calling a manual query
+    @query([], text, { manual: true })
+    async totallyManualQuery(): Promise<Manual<text>> {
+        ic.reply(await ic.call(this.canister2.manualQuery), text);
+    }
+
+    // Composite query calling another composite query
+    @query([], text)
+    async deepQuery(): Promise<text> {
+        return await ic.call(this.canister2.deepQuery);
+    }
+
+    // Composite query calling an update method. SHOULDN'T WORK
+    @query([], text)
+    async updateQuery(): Promise<text> {
+        return await ic.call(this.canister2.updateQuery);
+    }
+
+    // Composite query being called by a query method. SHOULDN'T WORK
+    @query([], text)
+    async simpleQuery(): Promise<text> {
+        return await ic.call(this.canister2.simpleQuery);
+    }
+
+    // Composite query being called by an update method. SHOULDN'T WORK
+    @update([], text)
+    async simpleUpdate(): Promise<text> {
+        return await ic.call(this.canister2.deepQuery);
+    }
+
+    // Composite query that modifies the state. Should revert after the call is done
+    @query([], nat)
+    async incCounter(): Promise<nat> {
+        this.counter += 1n;
+
+        return this.counter;
+    }
+
+    // Composite query calling queries on the same canister
+    @query([], nat)
+    async incCanister1(): Promise<nat> {
+        this.counter += 1n;
+
+        const canister1AResult = await ic.call(this.incCounter);
+
+        const canister1BResult = await ic.call(this.incCounter);
+
+        return this.counter + canister1AResult + canister1BResult;
+    }
+
+    // Composite query calling queries that modify the state
+    @query([], nat)
+    async incCanister2(): Promise<nat> {
+        this.counter += 1n;
+
+        const canister2AResult = await ic.call(this.canister2.incCounter);
+
+        const canister2BResult = await ic.call(this.canister2.incCounter);
+
+        return this.counter + canister2AResult + canister2BResult;
+    }
+}
+
+export default Canister1;

examples/composite_queries/canisters/canister2/index.did

@@ -0,0 +1,7 @@
+service: () -> {
+    incCounter: () -> (nat) query;
+    simpleQuery: () -> (text) query;
+    updateQuery: () -> (text);
+    manualQuery: () -> (text) query;
+    deepQuery: () -> (text) query;
+}

examples/composite_queries/canisters/canister2/index.ts

@@ -0,0 +1,40 @@
+import { ic, Manual, nat, Principal, query, Service, text, update } from 'azle';
+import Canister3 from '../canister3';
+
+export default class extends Service {
+    canister3 = new Canister3(
+        Principal.fromText(
+            process.env.CANISTER3_PRINCIPAL ??
+                ic.trap('process.env.CANISTER3_PRINCIPAL is undefined')
+        )
+    );
+
+    counter: nat = 0n;
+
+    // TODO is this supposed to be a query?
+    @query([], nat)
+    async incCounter(): Promise<nat> {
+        this.counter += 1n;
+        return this.counter;
+    }
+
+    @query([], text)
+    simpleQuery(): text {
+        return 'Hello from Canister 2';
+    }
+
+    @update([], text)
+    updateQuery(): text {
+        return 'Hello from a Canister 2 update';
+    }
+
+    @query([], text, { manual: true })
+    manualQuery(): Manual<text> {
+        ic.reply('Hello from Canister 2 manual query', text);
+    }
+
+    @query([], text)
+    async deepQuery(): Promise<text> {
+        return await ic.call(this.canister3.deepQuery);
+    }
+}