Feat: Added client destroy

.github/workflows/bindings-wasm-publish.yml

@@ -27,7 +27,7 @@ jobs:
       - name: Install wasm-bindgen-cli
         uses: jetli/wasm-bindgen-action@24ba6f9fff570246106ac3f80f35185600c3f6c9
         with:
-          version: "0.2.86"
+          version: "0.2.87"
 
       - name: Set up Node.js
         uses: actions/setup-node@v2

.github/workflows/bindings-wasm.yml

@@ -65,7 +65,7 @@ jobs:
       - name: Install wasm-bindgen-cli
         uses: jetli/wasm-bindgen-action@24ba6f9fff570246106ac3f80f35185600c3f6c9
         with:
-          version: "0.2.86"
+          version: "0.2.87"
 
       - name: Set Up Node.js ${{ matrix.node }} and Yarn Cache
         uses: actions/setup-node@v2

bindings/nodejs/CHANGELOG.md

@@ -21,11 +21,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## 1.0.0-rc.2 - 2023-0x-xx
 
+<<<<<<< HEAD
+### Added
+
+- `Client::destroy` to close an open handle;
+=======
 ### Changed
 
 - Rename `Account::prepareMintNativeToken` to `prepareCreateNativeToken`, `Account::prepareIncreaseNativeTokenSupply` to `prepareMintNativeToken`, `Account::prepareDecreaseNativeTokenSupply` to `prepareMeltNativeToken`;
 - Rename `MintNativeTokenParams` to `CreateNativeTokenParams`;
 - Rename `MintTokenTransaction` to `CreateNativeTokenTransaction` and `PreparedMintTokenTransaction` to `PreparedCreateNativeTokenTransaction` (including their corresponding `Data` types);
+>>>>>>> develop
 
 ### Fixed
 

bindings/nodejs/jest.config.js

@@ -3,6 +3,9 @@ module.exports = {
     preset: 'ts-jest',
     testEnvironment: 'node',
     testMatch: ['<rootDir>/tests/**/*.(test|spec).ts'],
+    verbose: false,
+    detectOpenHandles: true,
+    forceExit: true,
     moduleNameMapper: {
         'index.node': '<rootDir>/build/Release/index.node',
     },

bindings/nodejs/lib/bindings.ts

@@ -18,6 +18,7 @@ const {
     initLogger,
     callClientMethod,
     createClient,
+    destroyClient,
     listenMqtt,
     callWalletMethod,
     createWallet,
@@ -101,6 +102,7 @@ const callWalletMethodAsync = (
 export {
     initLogger,
     createClient,
+    destroyClient,
     createSecretManager,
     createWallet,
     callClientMethodAsync,

bindings/nodejs/lib/client/client-method-handler.ts

@@ -1,7 +1,12 @@
 // Copyright 2023 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-import { callClientMethodAsync, createClient, listenMqtt } from '../bindings';
+import {
+    callClientMethodAsync,
+    createClient,
+    listenMqtt,
+    destroyClient,
+} from '../bindings';
 import type { IClientOptions, __ClientMethods__ } from '../types/client';
 
 /** The MethodHandler which sends the commands to the Rust side. */
@@ -17,6 +22,10 @@ export class ClientMethodHandler {
         }
     }
 
+    async destroy() {
+        return destroyClient(this.methodHandler);
+    }
+
     async callMethod(method: __ClientMethods__): Promise<string> {
         return callClientMethodAsync(
             JSON.stringify(method),

bindings/nodejs/lib/client/client.ts

@@ -63,6 +63,10 @@ export class Client {
         this.methodHandler = new ClientMethodHandler(options);
     }
 
+    async destroy() {
+        return this.methodHandler.destroy();
+    }
+
     /**
      * Returns the node information together with the url of the used node
      * @returns { Promise<INodeInfoWrapper> }.

bindings/nodejs/lib/wallet/wallet.ts

@@ -79,7 +79,7 @@ export class Wallet {
      * Destroy the Wallet and drop its database connection.
      */
     async destroy(): Promise<void> {
-        await this.methodHandler.destroy();
+        return this.methodHandler.destroy();
     }
 
     /**

bindings/nodejs/package.json

@@ -14,7 +14,7 @@
         "prebuild-arm64": "prebuild --runtime napi --target 6 --prepack scripts/neon-build.js --strip --arch arm64",
         "rebuild": "node scripts/neon-build && tsc && node scripts/strip.js",
         "install": "prebuild-install --runtime napi --tag-prefix='iota-sdk-nodejs-v' && tsc || npm run rebuild",
-        "test": "jest --forceExit"
+        "test": "jest"
     },
     "author": "IOTA Foundation <[email protected]>",
     "license": "Apache-2.0",

bindings/nodejs/src/client.rs

@@ -9,26 +9,31 @@ use iota_sdk_bindings_core::{
     listen_mqtt as rust_listen_mqtt, ClientMethod, Response, Result,
 };
 use neon::prelude::*;
+use tokio::sync::RwLock;
 
 type JsCallback = Root<JsFunction<JsObject>>;
 
+// Wrapper so we can destroy the ClientMethodHandler
+pub type ClientMethodHandlerWrapperInner = Arc<RwLock<Option<ClientMethodHandler>>>;
+// Wrapper because we can't impl Finalize on ClientMethodHandlerWrapperInner
+pub struct ClientMethodHandlerWrapper(pub ClientMethodHandlerWrapperInner);
 pub struct ClientMethodHandler {
     channel: Channel,
     client: Client,
 }
 
-impl Finalize for ClientMethodHandler {}
+impl Finalize for ClientMethodHandlerWrapper {}
 
 impl ClientMethodHandler {
-    pub fn new(channel: Channel, options: String) -> Result<Arc<Self>> {
+    pub fn new(channel: Channel, options: String) -> Result<Self> {
         let runtime = tokio::runtime::Runtime::new().expect("error initializing client");
         let client = runtime.block_on(ClientBuilder::new().from_json(&options)?.finish())?;
 
-        Ok(Arc::new(Self { channel, client }))
+        Ok(Self { channel, client })
     }
 
-    pub(crate) fn new_with_client(channel: Channel, client: Client) -> Arc<Self> {
-        Arc::new(Self { channel, client })
+    pub(crate) fn new_with_client(channel: Channel, client: Client) -> Self {
+        Self { channel, client }
     }
 
     async fn call_method(&self, serialized_method: String) -> (String, bool) {
@@ -55,43 +60,66 @@ impl ClientMethodHandler {
     }
 }
 
-pub fn create_client(mut cx: FunctionContext) -> JsResult<JsBox<Arc<ClientMethodHandler>>> {
+pub fn create_client(mut cx: FunctionContext) -> JsResult<JsBox<ClientMethodHandlerWrapper>> {
     let options = cx.argument::<JsString>(0)?;
     let options = options.value(&mut cx);
     let channel = cx.channel();
     let method_handler = ClientMethodHandler::new(channel, options)
         .or_else(|e| cx.throw_error(serde_json::to_string(&Response::Error(e)).expect("json to string error")))?;
+    Ok(cx.boxed(ClientMethodHandlerWrapper(Arc::new(RwLock::new(Some(method_handler))))))
+}
 
-    Ok(cx.boxed(method_handler))
+pub fn destroy_client(mut cx: FunctionContext) -> JsResult<JsPromise> {
+    let method_handler = Arc::clone(&&cx.argument::<JsBox<ClientMethodHandlerWrapper>>(0)?.0);
+    let channel = cx.channel();
+    let (deferred, promise) = cx.promise();
+    crate::RUNTIME.spawn(async move {
+        *method_handler.write().await = None;
+        deferred.settle_with(&channel, move |mut cx| Ok(cx.undefined()));
+    });
+    Ok(promise)
 }
 
 pub fn call_client_method(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let method = cx.argument::<JsString>(0)?;
     let method = method.value(&mut cx);
-    let method_handler = Arc::clone(&&cx.argument::<JsBox<Arc<ClientMethodHandler>>>(1)?);
+    let method_handler = Arc::clone(&&cx.argument::<JsBox<ClientMethodHandlerWrapper>>(1)?.0);
     let callback = cx.argument::<JsFunction>(2)?.root(&mut cx);
 
+    let (sender, receiver) = std::sync::mpsc::channel();
     crate::RUNTIME.spawn(async move {
-        let (response, is_error) = method_handler.call_method(method).await;
-        method_handler.channel.send(move |mut cx| {
-            let cb = callback.into_inner(&mut cx);
-            let this = cx.undefined();
-
-            let args = [
-                if is_error {
-                    cx.string(response.clone()).upcast::<JsValue>()
-                } else {
-                    cx.undefined().upcast::<JsValue>()
-                },
-                cx.string(response).upcast::<JsValue>(),
-            ];
-
-            cb.call(&mut cx, this, args)?;
-
-            Ok(())
-        });
+        if let Some(method_handler) = &*method_handler.read().await {
+            let (response, is_error) = method_handler.call_method(method).await;
+            method_handler.channel.send(move |mut cx| {
+                let cb = callback.into_inner(&mut cx);
+                let this = cx.undefined();
+
+                let args = [
+                    if is_error {
+                        cx.string(response.clone()).upcast::<JsValue>()
+                    } else {
+                        cx.undefined().upcast::<JsValue>()
+                    },
+                    cx.string(response).upcast::<JsValue>(),
+                ];
+
+                cb.call(&mut cx, this, args)?;
+
+                Ok(())
+            });
+        } else {
+            // Notify that the client got destroyed
+            // Safe to unwrap because the receiver is waiting on it
+            sender.send(()).unwrap();
+        }
     });
 
+    if receiver.recv().is_ok() {
+        return cx.throw_error(
+            serde_json::to_string(&Response::Panic("Client got destroyed".to_string())).expect("json to string error"),
+        );
+    }
+
     Ok(cx.undefined())
 }
 
@@ -106,18 +134,22 @@ pub fn listen_mqtt(mut cx: FunctionContext) -> JsResult<JsPromise> {
     }
 
     let callback = Arc::new(cx.argument::<JsFunction>(1)?.root(&mut cx));
-    let method_handler = Arc::clone(&&cx.argument::<JsBox<Arc<ClientMethodHandler>>>(2)?);
+    let method_handler = Arc::clone(&&cx.argument::<JsBox<ClientMethodHandlerWrapper>>(2)?.0);
     let (deferred, promise) = cx.promise();
 
     crate::RUNTIME.spawn(async move {
-        let channel0 = method_handler.channel.clone();
-        let channel1 = method_handler.channel.clone();
-        rust_listen_mqtt(&method_handler.client, topics, move |event_data| {
-            call_event_callback(&channel0, event_data, callback.clone())
-        })
-        .await;
-
-        deferred.settle_with(&channel1, move |mut cx| Ok(cx.undefined()));
+        if let Some(method_handler) = &*method_handler.read().await {
+            let channel0 = method_handler.channel.clone();
+            let channel1 = method_handler.channel.clone();
+            rust_listen_mqtt(&method_handler.client, topics, move |event_data| {
+                call_event_callback(&channel0, event_data, callback.clone())
+            })
+            .await;
+
+            deferred.settle_with(&channel1, move |mut cx| Ok(cx.undefined()));
+        } else {
+            panic!("Client got destroyed")
+        }
     });
 
     Ok(promise)

bindings/nodejs/src/lib.rs

@@ -50,6 +50,7 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
     // Client
     cx.export_function("callClientMethod", client::call_client_method)?;
     cx.export_function("createClient", client::create_client)?;
+    cx.export_function("destroyClient", client::destroy_client)?;
     // MQTT
     cx.export_function("listenMqtt", client::listen_mqtt)?;
 

bindings/nodejs/src/wallet.rs

@@ -14,7 +14,10 @@ use iota_sdk_bindings_core::{
 use neon::prelude::*;
 use tokio::sync::RwLock;
 
-use crate::{client::ClientMethodHandler, secret_manager::SecretManagerMethodHandler};
+use crate::{
+    client::{ClientMethodHandler, ClientMethodHandlerWrapper},
+    secret_manager::SecretManagerMethodHandler,
+};
 
 // Wrapper so we can destroy the WalletMethodHandler
 pub type WalletMethodHandlerWrapperInner = Arc<RwLock<Option<WalletMethodHandler>>>;
@@ -187,7 +190,11 @@ pub fn get_client(mut cx: FunctionContext) -> JsResult<JsPromise> {
         if let Some(method_handler) = &*method_handler.read().await {
             let client_method_handler =
                 ClientMethodHandler::new_with_client(channel.clone(), method_handler.wallet.client().clone());
-            deferred.settle_with(&channel, move |mut cx| Ok(cx.boxed(client_method_handler)));
+            deferred.settle_with(&channel, move |mut cx| {
+                Ok(cx.boxed(ClientMethodHandlerWrapper(Arc::new(RwLock::new(Some(
+                    client_method_handler,
+                ))))))
+            });
         } else {
             deferred.settle_with(&channel, move |mut cx| {
                 cx.error(