wasm_bindgen function in api

crates/sp_client/src/api.rs

@@ -1,8 +1,8 @@
 use rand::Rng;
 
 use anyhow::Error as AnyhowError;
-use sp_backend::silentpayments::Error as SpError;
 use serde_json::Error as SerdeJsonError;
+use sp_backend::silentpayments::Error as SpError;
 
 use serde::{Deserialize, Serialize};
 use sp_backend::silentpayments::sending::SilentPaymentAddress;
@@ -13,6 +13,8 @@ use wasm_bindgen::prelude::*;
 use sp_backend::spclient::SpendKey;
 use sp_backend::spclient::{derive_keys_from_seed, OutputList, SpClient};
 
+use crate::process::{ItemMember, Process, Role};
+
 type ApiResult<T: FromWasmAbi> = Result<T, ApiError>;
 
 const IS_TESTNET: bool = true;
@@ -24,19 +26,25 @@ struct ApiError {
 
 impl From<AnyhowError> for ApiError {
     fn from(value: AnyhowError) -> Self {
-        ApiError {message: value.to_string()}
+        ApiError {
+            message: value.to_string(),
+        }
     }
 }
 
 impl From<SpError> for ApiError {
     fn from(value: SpError) -> Self {
-        ApiError { message: value.to_string() }
+        ApiError {
+            message: value.to_string(),
+        }
     }
 }
 
 impl From<SerdeJsonError> for ApiError {
     fn from(value: SerdeJsonError) -> Self {
-        ApiError { message: value.to_string() }
+        ApiError {
+            message: value.to_string(),
+        }
     }
 }
 
@@ -104,3 +112,39 @@ pub fn get_receiving_address(sp_client: String) -> String {
     let sp_client: SpClient = serde_json::from_str(&sp_client).unwrap();
     sp_client.get_receiving_address()
 }
+
+#[derive(Tsify, Serialize, Deserialize)]
+#[tsify(into_wasm_abi)]
+#[allow(non_camel_case_types)]
+pub struct get_process_return(Vec<Process>);
+
+#[wasm_bindgen]
+pub fn get_processes() -> ApiResult<get_process_return> {
+    let member1 = ItemMember::new(Role::Manager, String::from(""));
+    let member2 = ItemMember::new(Role::Manager, String::from(""));
+    let member3 = ItemMember::new(Role::Manager, String::from(""));
+
+    //instances of process
+    let process1 = Process {
+        id: String::from("1"),
+        version: String::from("1.0"),
+        gestionnaires: vec![member1.clone(), member2.clone()],
+    };
+    let process2 = Process {
+        id: String::from("2"),
+        version: String::from("2.0"),
+        gestionnaires: vec![member2.clone(), member3.clone()],
+    };
+    let process3 = Process {
+        id: String::from("3"),
+        version: String::from("1.0"),
+        gestionnaires: vec![member3.clone(), member1.clone()],
+    };
+
+    //  vec with the instances of processes
+    let mut data_process: Vec<Process> = Vec::new();
+    data_process.push(process1);
+    data_process.push(process2);
+    data_process.push(process3);
+    Ok(get_process_return(data_process))
+}

crates/sp_client/src/process.rs

@@ -1,97 +1,38 @@
-use wasm_bindgen::prelude::*;
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
-
-/* 
-#[wasm_bindgen]
-pub fn get_process() -> Vec<String> {
-    let mut data_process: Vec<String> = Vec::new();
-    data_process.push(String::from("process1"));
-    data_process.push(String::from("process2"));
-    data_process.push(String::from("process3"));
-    data_process
-}*/
+use tsify::Tsify;
+use wasm_bindgen::prelude::*;
 
 // process member (gestionnaire for now)
-#[derive(Debug)]
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
 pub enum Role {
-    manager,
-   // user
+    Manager,
+    #[default]
+    User,
 }
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-#[wasm_bindgen]
-pub struct itemMember {
-    role: Role, //gestionnaire 
-    sp_address: String,
+#[derive(Debug, Serialize, Deserialize, Default, Tsify, Clone)]
+#[tsify(into_wasm_abi)]
+pub struct ItemMember {
+    pub role: Role, //gestionnaire
+    pub sp_address: String,
     //pre_id
     //shard
     //priv_key_mainnet_spend
     //priv_key_mainnet_scan
     //priv_key_signet_scan
-
 }
-#[wasm_bindgen]
-impl itemMember{
-    pub fn new (
-        role : Role, 
-        sp_address: string)
-        ->Self {
-        itemMember{
-            role, 
-            sp_address,
-        }
+
+impl ItemMember {
+    pub fn new(role: Role, sp_address: String) -> Self {
+        ItemMember { role, sp_address }
     }
 }
 
+#[derive(Debug, Serialize, Deserialize, Default, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
 pub struct Process {
-    id: String,
-    version: String,
-    gestionnaires: Vec<itemMember>,
+    pub id: String,
+    pub version: String,
+    pub gestionnaires: Vec<ItemMember>,
     //item_name : String,
 }
-#[wasm_bindgen]
-pub fn get_processes() -> Vec<JsValue> {
-    let member1 = itemMember {
-        role: Role ::Manager,
-        sp_address: String::from(""),
-    };
-
-    let member2 = itemMember {
-        role: Role ::Manager,
-        sp_address: String::from(""),
-    };
-
-    let member3 = itemMember {
-        role: Role ::Manager,
-        sp_address: String::from(""),
-    };
-    /* 
-    let member4= itemMember{
-        role : Role :: User,
-        sp_address: String::from(""),
-    };
-    */
-    //instances of process 
-    let process1 = Process {
-        id: String::from("1"),
-        version: String::from("1.0"),
-        gestionnaires: vec![member1, member2],
-    };
-    let process2 = Process {
-        id: String::from("2"),
-        version: String::from("2.0"),
-        gestionnaires: vec![member2, member3],
-    };
-    let process3 = Process {
-        id: String::from("3"),
-        version: String::from("1.0"),
-        gestionnaires: vec![member3, member1],
-    };
- 
-    //  vec with the instances of processes
-    let mut data_process: Vec<JsValue> = Vec::new();
-    data_process.push(JsValue::from_serde(&process1).unwrap());
-    data_process.push(JsValue::from_serde(&process2).unwrap());
-    data_process.push(JsValue::from_serde(&process3).unwrap());
-    data_process
-}