edhoc 1.0.4 → 1.1.0

package/include/Utils.h

@@ -2,7 +2,9 @@
 #define UTILS_H
 
 #include <napi.h>
+
 #include <cstdint>
+#include <future>
 #include <string>
 #include <vector>
 
@@ -20,22 +22,8 @@ extern "C" {
  */
 class Utils {
  public:
-  /**
-   * Resets a JavaScript function reference and releases a thread-safe function.
-   * This helper function is designed to encapsulate the cleanup logic for N-API
-   * resources, ensuring that function references are reset and thread-safe
-   * functions are released properly. This prevents memory leaks and ensures
-   * that asynchronous operations using thread-safe functions do not attempt to
-   * call into JavaScript after the native resources have been disposed of.
-   *
-   * @param funcRef A reference to a N-API function that may be called from
-   * native code. This function reference will be reset if it is not empty.
-   * @param tsfn A N-API thread-safe function that facilitates calling
-   * JavaScript functions asynchronously from native threads. This thread-safe
-   * function will be released and set to nullptr.
-   */
-  static void ResetAndRelease(Napi::FunctionReference& funcRef,
-                              Napi::ThreadSafeFunction& tsfn);
+  using SuccessHandler = std::function<void(Napi::Env, Napi::Value)>;
+  using ErrorHandler = std::function<void(Napi::Env, Napi::Error)>;
 
   /**
    * Invokes a JavaScript function with promise handling.
@@ -50,12 +38,31 @@ class Utils {
    * @param callbackLambda A lambda function to handle the result of the
    * function call.
    */
-  static void InvokeJSFunctionWithPromiseHandling(
-      Napi::Env env,
-      Napi::Object jsObject,
-      Napi::Function jsCallback,
-      const std::vector<napi_value>& args,
-      std::function<void(Napi::Env, Napi::Value)> callbackLambda);
+  static void InvokeJSFunctionWithPromiseHandling(Napi::Env env,
+                                                  Napi::Object jsObject,
+                                                  Napi::Function jsCallback,
+                                                  const std::vector<napi_value>& args,
+                                                  SuccessHandler successLambda,
+                                                  ErrorHandler errorLambda);
+
+  /**
+   * Creates a promise error handler for a given promise.
+   *
+   * @tparam T The type of the promise.
+   * @param promise The promise to handle errors for.
+   * @return A lambda function that sets the exception on the promise.
+   */
+  template <typename T>
+  static ErrorHandler CreatePromiseErrorHandler(std::promise<T>& promise, T defaultValue) {
+    return [&promise, defaultValue](Napi::Env env, Napi::Error error) {
+      auto exception = std::current_exception();
+      if (exception) {
+        promise.set_exception(exception);
+      } else {
+        promise.set_value(defaultValue);
+      }
+    };
+  }
 
   /**
    * Converts a JavaScript value to an EDHOC connection ID structure.
@@ -75,8 +82,7 @@ class Utils {
    * @param value The EDHOC connection ID structure.
    * @return A N-API value representing the connection ID.
    */
-  static Napi::Value CreateJsValueFromEdhocCid(
-      Napi::Env env, struct edhoc_connection_id value);
+  static Napi::Value CreateJsValueFromEdhocCid(Napi::Env env, struct edhoc_connection_id value);
 
   /**
    * Converts a JavaScript number to a strongly typed enum.
@@ -102,9 +108,7 @@ class Utils {
    * @param length Pointer to a size_t variable where the length of the encoded
    * data will be stored.
    */
-  static void EncodeInt64ToBuffer(int64_t value,
-                                  uint8_t* buffer,
-                                  size_t* length);
+  static void EncodeInt64ToBuffer(int64_t value, uint8_t* buffer, size_t* length);
 };
 
 #endif  // UTILS_H

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "edhoc",
   "description": "A Node.js implementation of EDHOC (Ephemeral Diffie-Hellman Over COSE) protocol for lightweight authenticated key exchange in IoT and other constrained environments.",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "scripts": {
     "debug": "npx node-gyp build --debug",
@@ -13,7 +13,7 @@
     "semantic-release": "semantic-release",
     "pretest": "npm run rebuild",
     "rebuild": "node-gyp rebuild",
-    "test": "mocha --recursive \"test/*.test.js\" \"test/**/*.test.js\" --exit"
+    "test": "jest"
   },
   "private": false,
   "gypfile": true,
@@ -22,10 +22,13 @@
     "@noble/curves": "^1.4.0",
     "bindings": "^1.5.0",
     "cbor": "^9.0.2",
+    "chalk": "^5.3.0",
     "coap": "^1.3.0",
+    "colors": "^1.4.0",
     "node-addon-api": "^8.0.0",
     "node-gyp-build": "^4.8.1",
-    "patch-package": "^8.0.0"
+    "patch-package": "^8.0.0",
+    "wtfnode": "^0.9.3"
   },
   "devDependencies": {
     "@commitlint/cli": "^19.3.0",
@@ -37,13 +40,21 @@
     "@semantic-release/github": "^10.1.1",
     "@types/elliptic": "^6.4.18",
     "@types/eslint__js": "^8.42.3",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.4",
     "eslint": "^8.57.0",
+    "jest": "^29.7.0",
     "mocha": "^10.7.0",
     "nyc": "^17.0.0",
     "prebuildify": "^6.0.1",
     "prebuildify-cross": "^5.1.0",
     "semantic-release": "^24.0.0",
+    "ts-jest": "^29.2.5",
     "typescript": "^5.5.4",
     "typescript-eslint": "^7.17.0"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
   }
 }

package/src/EdhocComposeAsyncWorker.cpp

@@ -1,20 +1,16 @@
 #include "EdhocComposeAsyncWorker.h"
 
 static const size_t kInitialBufferSize = 1024 * 10;
-static constexpr const char* kErrorInvalidMessageNumber =
-    "Invalid message number";
-static constexpr const char* kErrorMessageFormat =
-    "Failed to compose EDHOC message %d. Error code: %d";
+static constexpr const char* kErrorInvalidMessageNumber = "Invalid message number";
+static constexpr const char* kErrorMessageFormat = "Failed to compose EDHOC message %d. Error code: %d";
 static constexpr size_t kErrorBufferSize = 100;
 
-EdhocComposeAsyncWorker::EdhocComposeAsyncWorker(
-    Napi::Env& env,
-    Napi::Promise::Deferred deferred,
-    struct edhoc_context& context,
-    int messageNumber,
-    CallbackType callback)
+EdhocComposeAsyncWorker::EdhocComposeAsyncWorker(Napi::Env& env,
+                                                 struct edhoc_context& context,
+                                                 int messageNumber,
+                                                 CallbackType callback)
     : Napi::AsyncWorker(env),
-      deferred(deferred),
+      deferred(Napi::Promise::Deferred::New(env)),
       context(context),
       messageNumber(messageNumber),
       callback(std::move(callback)) {}
@@ -27,28 +23,16 @@ void EdhocComposeAsyncWorker::Execute() {
     int ret = EDHOC_ERROR_GENERIC_ERROR;
     switch (messageNumber) {
       case EDHOC_MSG_1:
-        ret = edhoc_message_1_compose(&context,
-                                      composedMessage.data(),
-                                      composedMessage.size(),
-                                      &composedMessageLength);
+        ret = edhoc_message_1_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
         break;
       case EDHOC_MSG_2:
-        ret = edhoc_message_2_compose(&context,
-                                      composedMessage.data(),
-                                      composedMessage.size(),
-                                      &composedMessageLength);
+        ret = edhoc_message_2_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
         break;
       case EDHOC_MSG_3:
-        ret = edhoc_message_3_compose(&context,
-                                      composedMessage.data(),
-                                      composedMessage.size(),
-                                      &composedMessageLength);
+        ret = edhoc_message_3_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
         break;
       case EDHOC_MSG_4:
-        ret = edhoc_message_4_compose(&context,
-                                      composedMessage.data(),
-                                      composedMessage.size(),
-                                      &composedMessageLength);
+        ret = edhoc_message_4_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
         break;
       default:
         SetError(kErrorInvalidMessageNumber);
@@ -59,11 +43,7 @@ void EdhocComposeAsyncWorker::Execute() {
 
     if (ret != EDHOC_SUCCESS) {
       char errorMessage[kErrorBufferSize];
-      std::snprintf(errorMessage,
-                    kErrorBufferSize,
-                    kErrorMessageFormat,
-                    messageNumber + 1,
-                    ret);
+      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber + 1, ret);
       SetError(errorMessage);
     }
 
@@ -75,14 +55,17 @@ void EdhocComposeAsyncWorker::Execute() {
 void EdhocComposeAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  deferred.Resolve(Napi::Buffer<uint8_t>::Copy(
-      env, composedMessage.data(), composedMessage.size()));
+  deferred.Resolve(Napi::Buffer<uint8_t>::Copy(env, composedMessage.data(), composedMessage.size()));
   callback(env);
 }
 
 void EdhocComposeAsyncWorker::OnError(const Napi::Error& error) {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  deferred.Reject(Napi::String::New(env, error.Message()));
+  deferred.Reject(error.Value());
   callback(env);
 }
+
+Napi::Promise EdhocComposeAsyncWorker::GetPromise() {
+  return deferred.Promise();
+}