Generate node bindings using napi-rs

aries_vcx/Cargo.toml

@@ -47,6 +47,7 @@ derive_builder = "0.10.2"
 tokio = { version = "1.15.0" }
 messages = { path  = "../messages" }
 zmq = { version = "0.9.2" }
+napi = "=2.9.1"
 
 [target.'cfg(target_os = "android")'.dependencies]
 android_logger = "0.5"

aries_vcx/src/error.rs

@@ -333,6 +333,28 @@ impl From<SenderConfigBuilderError> for VcxError {
     }
 }
 
+impl From<VcxError> for napi::Error {
+    fn from(err: VcxError) -> Self {
+        let reason = err.to_string();
+        error!("{}", reason);
+        // Use message field to propagate information about error type
+        napi::Error::new(napi::Status::Unknown, format!("{:?}", Into::<u32>::into(err.kind())))
+    }
+}
+
+impl From<napi::Error> for VcxError {
+    fn from(err: napi::Error) -> Self {
+        let reason = err.to_string();
+        error!("{}", reason);
+        // TODO: This is hacky, there are other options
+        match err.reason.parse::<u32>() {
+            Ok(r) => VcxError::from(VcxErrorKind::from(r)),
+            Err(_) => VcxError::from_msg(VcxErrorKind::UnknownError, reason)
+
+        }
+    }
+}
+
 impl From<AgencyClientErrorKind> for VcxErrorKind {
     fn from(agency_err: AgencyClientErrorKind) -> VcxErrorKind {
         match agency_err {

aries_vcx/src/handlers/connection/mediated_connection.rs

@@ -776,11 +776,11 @@ impl MediatedConnection {
         }
     }
 
-    pub async fn send_generic_message(&self, wallet_handle: WalletHandle, message: &str) -> VcxResult<String> {
+    pub async fn send_generic_message(&self, wallet_handle: WalletHandle, message: &str) -> VcxResult<()> {
         trace!("MediatedConnection::send_generic_message >>> message: {:?}", message);
         let message = Self::build_basic_message(message);
         let send_message = self.send_message_closure(wallet_handle).await?;
-        send_message(message).await.map(|_| String::new())
+        send_message(message).await
     }
 
     pub async fn send_a2a_message(&self, wallet_handle: WalletHandle, message: &A2AMessage) -> VcxResult<String> {

aries_vcx/src/lib.rs

@@ -27,6 +27,8 @@ extern crate derive_builder;
 #[cfg(test)]
 extern crate async_channel;
 
+extern crate napi;
+
 pub extern crate messages;
 
 #[macro_use]

libvcx/Cargo.toml

@@ -28,6 +28,8 @@ chrono = "0.4.19"
 time = "0.1.44"
 lazy_static = "1.3"
 libc = "=0.2.114"
+napi = { version = "=2.9.1", default-features = false, features = [ "async" ] }
+napi-derive = { version = "=2.9.1" }
 rand = "0.7.3"
 serde = "1.0.97"
 serde_json = "1.0.40"
@@ -44,3 +46,6 @@ android_logger = "0.5"
 
 [dev-dependencies]
 tokio = { version = "1.15", features = [ "rt", "macros" ] }
+
+[build-dependencies]
+napi-build = "2.0.1"

libvcx/build.rs

@@ -1,3 +1,5 @@
+extern crate napi_build;
+
 use std::env;
 use std::fs;
 use std::path::Path;
@@ -33,4 +35,5 @@ fn main() {
             }
         }
     }
+    napi_build::setup();
 }

libvcx/src/api_lib/api_c/out_of_band.rs

@@ -29,8 +29,8 @@ pub extern "C" fn vcx_out_of_band_sender_create(
         config
     );
 
-    execute_async::<BoxFuture<'static, Result<(), ()>>>(Box::pin(async move {
-        match out_of_band::create_out_of_band(&config).await {
+    execute(move || {
+        match out_of_band::create_out_of_band(config) {
             Ok(handle) => {
                 trace!(
                     "vcx_out_of_band_sender_create_cb(command_handle: {}, rc: {}, handle: {})",
@@ -41,6 +41,7 @@ pub extern "C" fn vcx_out_of_band_sender_create(
                 cb(command_handle, error::SUCCESS.code_num, handle);
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_sender_create_cb(command_handle: {}, rc: {}, handle: {})",
@@ -50,7 +51,7 @@ pub extern "C" fn vcx_out_of_band_sender_create(
             }
         }
         Ok(())
-    }));
+    });
 
     error::SUCCESS.code_num
 }
@@ -73,7 +74,7 @@ pub extern "C" fn vcx_out_of_band_receiver_create(
     );
 
     execute(move || {
-        match out_of_band::create_out_of_band_msg_from_msg(&message) {
+        match out_of_band::create_out_of_band_msg_from_msg(message) {
             Ok(handle) => {
                 trace!(
                     "vcx_out_of_band_receiver_create_cb(command_handle: {}, rc: {}, handle: {})",
@@ -84,6 +85,7 @@ pub extern "C" fn vcx_out_of_band_receiver_create(
                 cb(command_handle, error::SUCCESS.code_num, handle);
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_receiver_create_cb(command_handle: {}, rc: {}, handle: {}):",
@@ -127,6 +129,7 @@ pub extern "C" fn vcx_out_of_band_sender_get_thread_id(
                 cb(command_handle, error::SUCCESS.code_num, thid.as_ptr());
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_sender_get_thread_id_cb(command_handle: {}, rc: {}, thid: {})",
@@ -170,6 +173,7 @@ pub extern "C" fn vcx_out_of_band_receiver_get_thread_id(
                 cb(command_handle, error::SUCCESS.code_num, thid.as_ptr());
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_receiver_get_thread_id_cb(command_handle: {}, rc: {}, thid: {})",
@@ -204,7 +208,7 @@ pub extern "C" fn vcx_out_of_band_sender_append_message(
     );
 
     execute(move || {
-        match out_of_band::append_message(handle, &message) {
+        match out_of_band::append_message(handle, message) {
             Ok(()) => {
                 trace!(
                     "vcx_out_of_band_sender_append_message_cb(command_handle: {}, rc: {})",
@@ -214,6 +218,7 @@ pub extern "C" fn vcx_out_of_band_sender_append_message(
                 cb(command_handle, error::SUCCESS.code_num);
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_sender_append_message_cb(command_handle: {}, rc: {})",
@@ -248,7 +253,7 @@ pub extern "C" fn vcx_out_of_band_sender_append_service(
     );
 
     execute(move || {
-        match out_of_band::append_service(handle, &service) {
+        match out_of_band::append_service(handle, service) {
             Ok(()) => {
                 trace!(
                     "vcx_out_of_band_sender_append_service_cb(command_handle: {}, rc: {})",
@@ -258,6 +263,7 @@ pub extern "C" fn vcx_out_of_band_sender_append_service(
                 cb(command_handle, error::SUCCESS.code_num);
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_sender_append_service_cb(command_handle: {}, rc: {})",
@@ -292,7 +298,7 @@ pub extern "C" fn vcx_out_of_band_sender_append_service_did(
     );
 
     execute(move || {
-        match out_of_band::append_service_did(handle, &did) {
+        match out_of_band::append_service_did(handle, did) {
             Ok(()) => {
                 trace!(
                     "vcx_out_of_band_sender_append_service_did_cb(command_handle: {}, rc: {})",
@@ -302,6 +308,7 @@ pub extern "C" fn vcx_out_of_band_sender_append_service_did(
                 cb(command_handle, error::SUCCESS.code_num);
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_sender_append_service_did_cb(command_handle: {}, rc: {})",
@@ -345,6 +352,7 @@ pub extern "C" fn vcx_out_of_band_receiver_extract_message(
                 cb(command_handle, error::SUCCESS.code_num, msg.as_ptr());
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_receiver_extract_message_cb(command_handle: {}, rc: {}, msg: {})",
@@ -388,6 +396,7 @@ pub extern "C" fn vcx_out_of_band_to_message(
                 cb(command_handle, error::SUCCESS.code_num, msg.as_ptr());
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_to_message_cb(command_handle: {}, rc: {}, msg: {})",
@@ -434,12 +443,14 @@ pub extern "C" fn vcx_out_of_band_receiver_connection_exists(
     };
 
     execute_async::<BoxFuture<'static, Result<(), ()>>>(Box::pin(async move {
-        match out_of_band::connection_exists(handle, &conn_handles).await {
-            Ok((conn_handle, found_one)) => {
+        match out_of_band::connection_exists(handle, conn_handles).await {
+            Ok(conn_handle) => {
+                let found_one = conn_handle == 0;
                 trace!("vcx_out_of_band_receiver_connection_exists_cb(command_handle: {}, rc: {}, conn_handle: {}, found_one: {})", command_handle, error::SUCCESS.message, conn_handle, found_one);
                 cb(command_handle, error::SUCCESS.code_num, conn_handle, found_one);
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!("vcx_out_of_band_receiver_connection_exists_cb(command_handle: {}, rc: {}, conn_handle: {}, found_one: {})", command_handle, err, 0, false);
                 cb(command_handle, err.into(), 0, false);
@@ -480,6 +491,7 @@ pub extern "C" fn vcx_out_of_band_receiver_build_connection(
                 cb(command_handle, error::SUCCESS.code_num, connection.as_ptr());
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_receiver_build_connection_cb(command_handle: {}, rc: {}, connection: {})",
@@ -523,6 +535,7 @@ pub extern "C" fn vcx_out_of_band_sender_serialize(
                 cb(command_handle, error::SUCCESS.code_num, oob_json.as_ptr());
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_sender_serialize_cb(command_handle: {}, rc: {}, oob_json: {})",
@@ -566,6 +579,7 @@ pub extern "C" fn vcx_out_of_band_receiver_serialize(
                 cb(command_handle, error::SUCCESS.code_num, oob_json.as_ptr());
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_receiver_serialize_cb(command_handle: {}, rc: {}, oob_json: {})",
@@ -598,7 +612,7 @@ pub extern "C" fn vcx_out_of_band_sender_deserialize(
     );
 
     execute(move || {
-        match out_of_band::from_string_sender(&oob_json) {
+        match out_of_band::from_string_sender(oob_json) {
             Ok(handle) => {
                 trace!(
                     "vcx_out_of_band_sender_deserialize_cb(command_handle: {}, rc: {}, handle: {})",
@@ -609,6 +623,7 @@ pub extern "C" fn vcx_out_of_band_sender_deserialize(
                 cb(command_handle, error::SUCCESS.code_num, handle);
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_sender_deserialize_cb(command_handle: {}, rc: {}, handle: {})",
@@ -641,7 +656,7 @@ pub extern "C" fn vcx_out_of_band_receiver_deserialize(
     );
 
     execute(move || {
-        match out_of_band::from_string_receiver(&oob_json) {
+        match out_of_band::from_string_receiver(oob_json) {
             Ok(handle) => {
                 trace!(
                     "vcx_out_of_band_receiver_deserialize_cb(command_handle: {}, rc: {}, handle: {})",
@@ -652,6 +667,7 @@ pub extern "C" fn vcx_out_of_band_receiver_deserialize(
                 cb(command_handle, error::SUCCESS.code_num, handle);
             }
             Err(err) => {
+                let err: VcxError = err.into();
                 set_current_error_vcx(&err);
                 error!(
                     "vcx_out_of_band_receiver_deserialize_cb(command_handle: {}, rc: {}, handle: {})",
@@ -680,6 +696,7 @@ pub extern "C" fn vcx_out_of_band_sender_release(handle: u32) -> u32 {
             error::SUCCESS.code_num
         }
         Err(err) => {
+            let err: VcxError = err.into();
             error!("vcx_out_of_band_sender_release(handle: {}), rc: {})", handle, err);
             err.into()
         }
@@ -700,6 +717,7 @@ pub extern "C" fn vcx_out_of_band_receiver_release(handle: u32) -> u32 {
             error::SUCCESS.code_num
         }
         Err(err) => {
+            let err: VcxError = err.into();
             error!("vcx_out_of_band_receiver_release(handle: {}), rc: {})", handle, err);
             err.into()
         }