asherah 3.0.4 → 3.0.5

package/binding.gyp

@@ -14,19 +14,21 @@
           '-g',
           '-O3',
           '-std=c++17',
-          '-fPIC'
+          '-fPIC',
+          '-Wno-unknown-pragmas'
         ],
       },
       'defines': [ 
         'NAPI_CPP_EXCEPTIONS',
         'NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS',
         'NODE_ADDON_API_DISABLE_DEPRECATED',
-        'NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED'
+        'NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED',
+        'USE_SCOPED_ALLOCATE_BUFFER',
         ],
       'sources': [
         'src/asherah.cc',
-        'src/logging.cc',
-        'src/logging_napi.cc'
+        'src/logging_napi.cc',
+        'src/logging_stderr.cc'
       ],
       'libraries': [ '../lib/libasherah.a' ]
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asherah",
-  "version": "3.0.4",
+  "version": "3.0.5",
   "description": "Asherah envelope encryption and key rotation library",
   "exports": {
     "node-addons": "./dist/asherah.node"
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "preinstall": "scripts/download-libraries.sh",
-    "load": "node --max-old-space-size=500 scripts/dumpster-fire.js",
+    "load": "node --max-old-space-size=500 scripts/dumpster-fire-memory.js",
     "install": "scripts/build.sh",
     "test:mocha-debug": "lldb -o run -- node node_modules/mocha/bin/mocha --inspect-brk",
     "test:mocha": "mocha",
@@ -30,10 +30,11 @@
     "src/cobhan_buffer_napi.h",
     "src/cobhan_buffer.h",
     "src/hints.h",
-    "src/logging.cc",
     "src/logging.h",
     "src/logging_napi.cc",
     "src/logging_napi.h",
+    "src/logging_stderr.cc",
+    "src/logging_stderr.h",
     "src/napi_utils.h",
     "src/scoped_allocate.h",
     "src/asherah.d.ts",
@@ -70,6 +71,6 @@
   },
   "types": "dist/asherah.d.ts",
   "dependencies": {
-    "node-addon-api": "7.0.0"
+    "node-addon-api": "^7.0.0"
   }
 }

package/scripts/build.sh

@@ -1,3 +1,16 @@
 #!/bin/bash
 
-node-gyp configure && node-gyp build && mkdir -p dist/ && cp build/Release/asherah.node dist/asherah.node && cp src/asherah.d.ts dist/asherah.d.ts
+set -e
+
+mkdir -p dist/
+
+# Check if USE_CMAKE is set to 1
+if [ "$USE_CMAKE" = "1" ]; then
+    # Run CMake commands
+    (cmake . && make) || exit 1
+else
+    # Run node-gyp commands
+    node-gyp configure && node-gyp build && cp build/Release/asherah.node dist/asherah.node
+fi
+
+cp src/asherah.d.ts dist/asherah.d.ts

package/src/asherah.cc

@@ -1,21 +1,16 @@
+#pragma clang diagnostic push
+#pragma ide diagnostic ignored "readability-convert-member-functions-to-static"
 
-#define USE_SCOPE_ALLOCATE_BUFFER 1
 #include "asherah_async_worker.h"
 #include "cobhan_buffer_napi.h"
 #include "hints.h"
 #include "libasherah.h"
 #include "logging_napi.h"
 #include "napi_utils.h"
-#ifdef USE_SCOPED_ALLOCATE_BUFFER
 #include "scoped_allocate.h"
-#endif
 #include <atomic>
 #include <napi.h>
 
-#ifndef NAPI_CPP_EXCEPTIONS
-#error Support for C++ exceptions is required
-#endif
-
 static volatile std::atomic<int32_t> setup_state{0};
 
 class Asherah : public Napi::Addon<Asherah> {
@@ -71,7 +66,7 @@ private:
       char *config_cbuffer;
       size_t config_cbuffer_size =
           CobhanBufferNapi::StringToAllocationSize(env, config_string);
-      SCOPED_ALLOCATE_BUFFER(logger, config_cbuffer, config_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(config_cbuffer, config_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       CobhanBufferNapi config(env, config_string, config_cbuffer,
@@ -166,14 +161,13 @@ private:
       char *partition_id_cbuffer;
       size_t partition_id_cbuffer_size =
           CobhanBufferNapi::StringToAllocationSize(env, partition_id_string);
-      SCOPED_ALLOCATE_BUFFER(logger, partition_id_cbuffer,
-                             partition_id_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(partition_id_cbuffer, partition_id_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       char *input_cbuffer;
       size_t input_cbuffer_size =
           CobhanBufferNapi::ValueToAllocationSize(env, input_value);
-      SCOPED_ALLOCATE_BUFFER(logger, input_cbuffer, input_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(input_cbuffer, input_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       CobhanBufferNapi partition_id(env, partition_id_string,
@@ -195,11 +189,11 @@ private:
       char *output_cobhan_buffer;
       size_t output_size_bytes =
           CobhanBuffer::DataSizeToAllocationSize(asherah_output_size_bytes);
-      SCOPED_ALLOCATE_BUFFER(logger, output_cobhan_buffer, output_size_bytes,
+      SCOPED_ALLOCATE_BUFFER(output_cobhan_buffer, output_size_bytes,
                              maximum_stack_alloc_size, __func__);
-      CobhanBufferNapi output(output_cobhan_buffer, output_size_bytes);
+      CobhanBufferNapi output(env, output_cobhan_buffer, output_size_bytes);
 #else
-      CobhanBufferNapi output(asherah_output_size_bytes);
+      CobhanBufferNapi output(env, asherah_output_size_bytes);
 #endif
 
       GoInt32 result = EncryptToJson(partition_id, input, output);
@@ -233,7 +227,7 @@ private:
       size_t asherah_output_size_bytes = EstimateAsherahOutputSize(
           input_data_len_bytes, partition_id_data_len_bytes);
 
-      CobhanBufferNapi output(asherah_output_size_bytes);
+      CobhanBufferNapi output(env, asherah_output_size_bytes);
 
       auto worker =
           new EncryptAsherahWorker(env, this, partition_id, input, output);
@@ -263,14 +257,13 @@ private:
       char *partition_id_cbuffer;
       size_t partition_id_cbuffer_size =
           CobhanBufferNapi::StringToAllocationSize(env, partition_id_string);
-      SCOPED_ALLOCATE_BUFFER(logger, partition_id_cbuffer,
-                             partition_id_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(partition_id_cbuffer, partition_id_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       char *input_cbuffer;
       size_t input_cbuffer_size =
           CobhanBufferNapi::ValueToAllocationSize(env, input_value);
-      SCOPED_ALLOCATE_BUFFER(logger, input_cbuffer, input_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(input_cbuffer, input_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       CobhanBufferNapi partition_id(env, partition_id_string,
@@ -282,13 +275,13 @@ private:
       char *output_cobhan_buffer;
       size_t output_size_bytes =
           CobhanBuffer::DataSizeToAllocationSize(input.get_data_len_bytes());
-      SCOPED_ALLOCATE_BUFFER(logger, output_cobhan_buffer, output_size_bytes,
+      SCOPED_ALLOCATE_BUFFER(output_cobhan_buffer, output_size_bytes,
                              maximum_stack_alloc_size, __func__);
-      CobhanBufferNapi output(output_cobhan_buffer, output_size_bytes);
+      CobhanBufferNapi output(env, output_cobhan_buffer, output_size_bytes);
 #else
       CobhanBufferNapi partition_id(env, partition_id_string);
       CobhanBufferNapi input(env, input_value);
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
 #endif
 
       // extern GoInt32 DecryptFromJson(void* partitionIdPtr, void* jsonPtr,
@@ -297,7 +290,7 @@ private:
 
       CheckResult(env, result);
 
-      output_value = output.ToBuffer(env); // NOLINT(*-slicing)
+      output_value = output.ToBuffer(); // NOLINT(*-slicing)
     } catch (Napi::Error &e) {
       e.ThrowAsJavaScriptException();
       return env.Undefined();
@@ -321,7 +314,7 @@ private:
       CobhanBufferNapi partition_id(env, partition_id_string);
       CobhanBufferNapi input(env, input_value);
 
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
       auto worker = new DecryptFromJsonWorker<Napi::Buffer<unsigned char>>(
           env, this, partition_id, input, output);
       worker->Queue();
@@ -351,14 +344,13 @@ private:
       char *partition_id_cbuffer;
       size_t partition_id_cbuffer_size =
           CobhanBufferNapi::StringToAllocationSize(env, partition_id_string);
-      SCOPED_ALLOCATE_BUFFER(logger, partition_id_cbuffer,
-                             partition_id_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(partition_id_cbuffer, partition_id_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       char *input_cbuffer;
       size_t input_cbuffer_size =
           CobhanBufferNapi::ValueToAllocationSize(env, input_value);
-      SCOPED_ALLOCATE_BUFFER(logger, input_cbuffer, input_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(input_cbuffer, input_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       CobhanBufferNapi partition_id(env, partition_id_string,
@@ -367,11 +359,11 @@ private:
       CobhanBufferNapi input(env, input_value, input_cbuffer,
                              input_cbuffer_size);
 
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
 #else
       CobhanBufferNapi partition_id(env, partition_id_string);
       CobhanBufferNapi input(env, input_value);
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
 #endif
 
       GoInt32 result = DecryptFromJson(partition_id, input, output);
@@ -401,7 +393,7 @@ private:
       CobhanBufferNapi partition_id(env, partition_id_string);
       CobhanBufferNapi input(env, input_value);
 
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
 
       auto worker = new DecryptFromJsonWorker<Napi::String>(
           env, this, partition_id, input, output);
@@ -418,41 +410,79 @@ private:
   }
 
   void SetMaxStackAllocItemSize(const Napi::CallbackInfo &info) {
-    NapiUtils::RequireParameterCount(info, 1);
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    try {
+      NapiUtils::RequireParameterCount(info, 1);
 
-    Napi::Number item_size = info[0].ToNumber();
-    auto new_size = (size_t)item_size.Int32Value();
+      Napi::Number item_size = info[0].ToNumber();
+      auto new_size = (size_t)item_size.Int32Value();
 
-    maximum_stack_alloc_size = new_size;
-    //TODO: This needs exception handling consistent with other methods
+      maximum_stack_alloc_size = new_size;
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
+    } catch (const std::exception &e) {
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
+    }
   }
 
   void SetSafetyPaddingOverhead(const Napi::CallbackInfo &info) {
-    NapiUtils::RequireParameterCount(info, 1);
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    try {
+      NapiUtils::RequireParameterCount(info, 1);
 
-    // Napi::Number safety_padding_number = info[0].ToNumber();
-    // auto new_safety_padding_bytes = (size_t)
-    // safety_padding_number.Int32Value(); Safety padding size is now fixed -
-    // ignore the input set_safety_padding_bytes(new_safety_padding_bytes);
+      // Napi::Number safety_padding_number = info[0].ToNumber();
+      // auto new_safety_padding_bytes = (size_t)
+      // safety_padding_number.Int32Value(); Safety padding size is now fixed -
+      // ignore the input set_safety_padding_bytes(new_safety_padding_bytes);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
+    } catch (const std::exception &e) {
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
+    }
   }
 
   Napi::Value
   GetSetupStatus(const Napi::CallbackInfo
                      &info) { // NOLINT(*-convert-member-functions-to-static)
-    int32_t setup_status = setup_state.load(std::memory_order_acquire);
-    return Napi::Boolean::New(info.Env(), setup_status != 0);
-    //TODO: This needs exception handling consistent with other methods
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    try {
+      int32_t setup_status = setup_state.load(std::memory_order_acquire);
+      return Napi::Boolean::New(info.Env(), setup_status != 0);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
+    } catch (const std::exception &e) {
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
   }
 
   void SetLogHook(const Napi::CallbackInfo &info) {
-    NapiUtils::RequireParameterCount(info, 1);
 
-    if (unlikely(!info[0].IsFunction())) {
-      NapiUtils::ThrowException(info.Env(), "Expected a function");
-    }
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    try {
+      NapiUtils::RequireParameterCount(info, 1);
 
-    logger.set_log_hook(info[0].As<Napi::Function>());
-    //TODO: This needs exception handling consistent with other methods
+      if (unlikely(!info[0].IsFunction())) {
+        NapiUtils::ThrowException(info.Env(), "Expected a function");
+      }
+
+      logger.set_log_hook(info[0].As<Napi::Function>());
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
+    } catch (const std::exception &e) {
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
+    }
   }
 
   void BeginSetupAsherah(const Napi::Env &env, const char *func_name,
@@ -487,7 +517,8 @@ private:
 
     auto old_setup_state = setup_state.exchange(1, std::memory_order_acq_rel);
     if (unlikely(old_setup_state != 0)) {
-      NapiUtils::ThrowException(env, "EndSetupAsherah: lost race to mark setup_state?!");
+      NapiUtils::ThrowException(
+          env, "EndSetupAsherah: lost race to mark setup_state?!");
     }
   }
 
@@ -506,14 +537,15 @@ private:
                         Napi::String &output_string) {
     CheckResult(env, result);
 
-    output_string = output.ToString(env);
+    output_string = output.ToString();
   }
 
-  void EndEncryptToJson(Napi::Env env, CobhanBufferNapi &output, GoInt32 result,
-                        Napi::Buffer<unsigned char> &output_buffer) {
+  [[maybe_unused]] void
+  EndEncryptToJson(Napi::Env env, CobhanBufferNapi &output, GoInt32 result,
+                   Napi::Buffer<unsigned char> &output_buffer) {
     CheckResult(env, result);
 
-    output_buffer = output.ToBuffer(env);
+    output_buffer = output.ToBuffer();
   }
 
   void BeginDecryptFromJson(const Napi::Env &env, const char *func_name,
@@ -532,14 +564,14 @@ private:
                           Napi::Buffer<unsigned char> &output_buffer) {
     CheckResult(env, result);
 
-    output_buffer = output.ToBuffer(env);
+    output_buffer = output.ToBuffer();
   }
 
   void EndDecryptFromJson(Napi::Env &env, CobhanBufferNapi &output,
                           GoInt32 result, Napi::String &output_string) {
     CheckResult(env, result);
 
-    output_string = output.ToString(env);
+    output_string = output.ToString();
   }
 
   void BeginShutdownAsherah(const Napi::Env &env, const char *func_name,
@@ -551,7 +583,8 @@ private:
   void EndShutdownAsherah(Napi::Env &env) {
     auto old_setup_state = setup_state.exchange(0, std::memory_order_acq_rel);
     if (unlikely(old_setup_state == 0)) {
-      NapiUtils::ThrowException(env, "EndSetupAsherah: lost race to mark setup_state?!");
+      NapiUtils::ThrowException(
+          env, "EndSetupAsherah: lost race to mark setup_state?!");
     }
   }
 
@@ -626,10 +659,10 @@ private:
     Napi::Value OnOKTask(Napi::Env &env) override {
       T output_result;
       asherah->EndDecryptFromJson(env, output, result, output_result);
-      return output_result;
+      return output_result; // NOLINT(*-slicing)
     }
 
-  protected:
+  private:
     CobhanBufferNapi partition_id;
     CobhanBufferNapi input;
     CobhanBufferNapi output;
@@ -663,18 +696,23 @@ private:
 
   void RequireAsherahSetup(const Napi::Env &env, const char *func_name) {
     if (unlikely(setup_state.load(std::memory_order_acquire) == 0)) {
-      NapiUtils::ThrowException(env, "RequireAsherahSetup: setup() not called");
+      NapiUtils::ThrowException(
+          env,
+          std::string(func_name) + ": RequireAsherahSetup: setup() not called");
     }
   }
 
   void RequireAsherahNotSetup(const Napi::Env &env, const char *func_name) {
     if (unlikely(setup_state.load(std::memory_order_acquire) != 0)) {
-      NapiUtils::ThrowException(env, "RequireAsherahNotSetup: setup() already called");
+      NapiUtils::ThrowException(
+          env, std::string(func_name) +
+                   ": RequireAsherahNotSetup: setup() already called");
     }
   }
 
-  __attribute__((always_inline)) inline size_t
-  EstimateAsherahOutputSize(size_t data_byte_len, size_t partition_byte_len) {
+  [[nodiscard]] __attribute__((always_inline)) inline size_t
+  EstimateAsherahOutputSize(size_t data_byte_len,
+                            size_t partition_byte_len) const {
     const size_t est_encryption_overhead = 48;
     const size_t est_envelope_overhead = 185;
     const double base64_overhead = 1.34;
@@ -733,3 +771,5 @@ private:
 };
 
 NODE_API_NAMED_ADDON(asherah, Asherah)
+
+#pragma clang diagnostic pop

package/src/asherah.d.ts

@@ -1,3 +1,5 @@
+// noinspection JSUnusedGlobalSymbols,DuplicatedCode
+
 /// <reference types="node" />
 export type AsherahConfig = {
     /** The name of this service (Required) */

package/src/asherah_async_worker.h

@@ -1,14 +1,9 @@
-// asherah_async_worker.h
 #ifndef ASHERAH_ASYNC_WORKER_H
 #define ASHERAH_ASYNC_WORKER_H
 
 #include <napi.h>
 #include <stdexcept>
 
-#ifndef NAPI_CPP_EXCEPTIONS
-#error Support for C++ exceptions is required
-#endif
-
 class Asherah;
 
 template <typename ResultType>

package/src/cobhan_buffer.h

@@ -52,16 +52,16 @@ public:
     return static_cast<void *>(cbuffer);
   }
 
-  char *get_data_ptr() const { return data_ptr; }
+  [[nodiscard]] char *get_data_ptr() const { return data_ptr; }
 
-  size_t get_data_len_bytes() const { return *data_len_ptr; }
+  [[nodiscard]] size_t get_data_len_bytes() const { return *data_len_ptr; }
 
   ~CobhanBuffer() {
     verify_canaries();
     cleanup();
   }
 
-    __attribute__((unused)) std::string DebugPrintStdErr() const {
+  [[nodiscard]] __attribute__((unused)) std::string DebugPrintStdErr() const {
     auto debug_string = std::string(get_data_ptr(), get_data_len_bytes());
     std::ostringstream debug_output;
     debug_output << "CobhanBuffer { " << std::endl
@@ -127,7 +127,7 @@ protected:
     }
   }
 
-  size_t get_allocation_size() const { return allocation_size; }
+  [[nodiscard]] size_t get_allocation_size() const { return allocation_size; }
 
   void set_data_len_bytes(size_t data_len_bytes) {
     if (data_len_bytes > max_int32_size) {

package/src/cobhan_buffer_napi.h

@@ -6,35 +6,30 @@
 #include <napi.h>
 #include <stdexcept>
 
-#ifndef NAPI_CPP_EXCEPTIONS
-#error Support for C++ exceptions is required
-#endif
-
 class CobhanBufferNapi : public CobhanBuffer {
 public:
   // Constructor from a Napi::String
   CobhanBufferNapi(const Napi::Env &env, const Napi::String &napiString)
-      : CobhanBuffer(NapiUtils::GetUtf8StringLength(env, napiString) +
-                     1) { // Add one for possible NULL delimiter due to Node
-                          // string functions
-    copy_from_string(env, napiString);
+      : CobhanBuffer(NapiUtils::GetUtf8StringLength(env, napiString) + 1),
+        env(env) { // Add one for possible NULL delimiter due to Node
+                   // string functions
+    copy_from_string(napiString);
   }
 
   // Constructor from Napi::Buffer<unsigned char>
   explicit CobhanBufferNapi(const Napi::Env &env,
                             const Napi::Buffer<unsigned char> &napiBuffer)
-      : CobhanBuffer(napiBuffer.ByteLength()) {
+      : CobhanBuffer(napiBuffer.ByteLength()), env(env) {
     std::memcpy(get_data_ptr(), napiBuffer.Data(), napiBuffer.ByteLength());
   }
 
   // Constructor from Napi::Value
   explicit CobhanBufferNapi(const Napi::Env &env, const Napi::Value &napiValue)
-      : CobhanBuffer(ValueToDataSize(env, napiValue)) {
+      : CobhanBuffer(ValueToDataSize(env, napiValue)), env(env) {
     if (napiValue.IsString()) {
-      copy_from_string(env, napiValue.As<Napi::String>());
+      copy_from_string(napiValue.As<Napi::String>());
     } else if (napiValue.IsBuffer()) {
-      Napi::Buffer<unsigned char> napiBuffer =
-          napiValue.As<Napi::Buffer<unsigned char>>();
+      auto napiBuffer = napiValue.As<Napi::Buffer<unsigned char>>();
       std::memcpy(get_data_ptr(), napiBuffer.Data(), napiBuffer.Length());
     } else {
       NapiUtils::ThrowException(
@@ -47,26 +42,25 @@ public:
   CobhanBufferNapi(const Napi::Env &env,
                    const Napi::Buffer<unsigned char> &napiBuffer, char *cbuffer,
                    size_t allocation_size)
-      : CobhanBuffer(cbuffer, allocation_size) {
+      : CobhanBuffer(cbuffer, allocation_size), env(env) {
     std::memcpy(get_data_ptr(), napiBuffer.Data(), napiBuffer.Length());
   }
 
   // Constructor from a Napi::String to an externally allocated buffer
   CobhanBufferNapi(const Napi::Env &env, const Napi::String &napiString,
                    char *cbuffer, size_t allocation_size)
-      : CobhanBuffer(cbuffer, allocation_size) {
-    copy_from_string(env, napiString);
+      : CobhanBuffer(cbuffer, allocation_size), env(env) {
+    copy_from_string(napiString);
   }
 
   // Constructor from a Napi::String to an externally allocated buffer
   CobhanBufferNapi(const Napi::Env &env, const Napi::Value &napiValue,
                    char *cbuffer, size_t allocation_size)
-      : CobhanBuffer(cbuffer, allocation_size) {
+      : CobhanBuffer(cbuffer, allocation_size), env(env) {
     if (napiValue.IsString()) {
-      copy_from_string(env, napiValue.As<Napi::String>());
+      copy_from_string(napiValue.As<Napi::String>());
     } else if (napiValue.IsBuffer()) {
-      Napi::Buffer<unsigned char> napiBuffer =
-          napiValue.As<Napi::Buffer<unsigned char>>();
+      auto napiBuffer = napiValue.As<Napi::Buffer<unsigned char>>();
       std::memcpy(get_data_ptr(), napiBuffer.Data(), napiBuffer.Length());
     } else {
       NapiUtils::ThrowException(
@@ -77,17 +71,18 @@ public:
 
   // Constructor from size_t representing data length in bytes (not allocation
   // size)
-  explicit CobhanBufferNapi(size_t data_len_bytes)
-      : CobhanBuffer(data_len_bytes) {}
+  explicit CobhanBufferNapi(const Napi::Env &env, size_t data_len_bytes)
+      : CobhanBuffer(data_len_bytes), env(env) {}
 
   // Constructor from externally allocated char* and size_t representing
   // allocation size in bytes
-  explicit CobhanBufferNapi(char *cbuffer, size_t allocation_size)
-      : CobhanBuffer(cbuffer, allocation_size) {}
+  explicit CobhanBufferNapi(const Napi::Env &env, char *cbuffer,
+                            size_t allocation_size)
+      : CobhanBuffer(cbuffer, allocation_size), env(env) {}
 
   // Move constructor
   CobhanBufferNapi(CobhanBufferNapi &&other) noexcept
-      : CobhanBuffer(std::move(other)) {}
+      : CobhanBuffer(std::move(other)), env(other.env) {}
 
   // Move assignment operator
   CobhanBufferNapi &operator=(CobhanBufferNapi &&other) noexcept {
@@ -98,7 +93,7 @@ public:
   }
 
   // Returns a Napi::String from the buffer using napi_create_string_utf8
-  Napi::String ToString(const Napi::Env &env) const {
+  [[nodiscard]] Napi::String ToString() const {
     napi_value napiStr;
     napi_status status = napi_create_string_utf8(
         env, get_data_ptr(), get_data_len_bytes(), &napiStr);
@@ -113,7 +108,7 @@ public:
   }
 
   // Returns a Napi::Buffer<unsigned char> from the buffer
-  Napi::Buffer<unsigned char> ToBuffer(const Napi::Env &env) const {
+  [[nodiscard]] Napi::Buffer<unsigned char> ToBuffer() const {
     auto buffer = Napi::Buffer<unsigned char>::Copy(
         env, reinterpret_cast<unsigned char *>(get_data_ptr()),
         get_data_len_bytes());
@@ -167,9 +162,11 @@ public:
   }
 
 private:
-  void copy_from_string(const Napi::Env &env, const Napi::String &napiString) {
-    size_t str_len = NapiUtils::GetUtf8StringLength(env, napiString);
+  Napi::Env env;
 
+  void copy_from_string(const Napi::String &napiString) {
+    size_t str_len = NapiUtils::GetUtf8StringLength(env, napiString);
+    // Add one for NULL delimiter due to napi_get_value_string_utf8
     size_t allocation_size =
         CobhanBuffer::DataSizeToAllocationSize(str_len) + 1;
 
@@ -179,6 +176,7 @@ private:
           "Buffer allocation size is insufficient to hold the Napi::String.");
     }
 
+    // Bytes written is the number of bytes copied, excluding the NULL
     size_t bytes_written;
     napi_status status = napi_get_value_string_utf8(
         env, napiString, get_data_ptr(), str_len + 1, &bytes_written);
@@ -189,6 +187,7 @@ private:
                    ", Bytes Written: " + std::to_string(bytes_written));
     }
 
+    // Update our data length to the actual string length
     set_data_len_bytes(str_len);
   }
 };

package/src/logging.h

@@ -1,13 +1,17 @@
+#pragma clang diagnostic push
+#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"
+
 #ifndef LOGGING_H
 #define LOGGING_H
+
+#include <cstddef> // size_t
+#include <cstdint> // int32_t
 #include <sstream> // std::ostringstream
 #include <string>  // std::string
-#include <cstdint> // int32_t
-#include <cstddef> // size_t
 
 class Logger {
 public:
-  void set_verbose_flag(int32_t verbose_flag);
+    [[maybe_unused]] void set_verbose_flag(int32_t verbose) { verbose_flag = verbose != 0; };
 
   virtual void debug_log(const char *function_name,
                          const char *message) const = 0;
@@ -34,21 +38,12 @@ public:
   }
 
 protected:
-  explicit Logger(const std::string &system_name);
-
   bool verbose_flag = false;
   std::string system_name;
 
-  void stderr_debug_log(const char *function_name, const char *message) const;
-  void stderr_debug_log(const char *function_name,
-                        const std::string &message) const;
-  void stderr_debug_log_alloca(const char *function_name,
-                               const char *variable_name, size_t length) const;
-  void stderr_debug_log_new(const char *function_name,
-                            const char *variable_name, size_t length) const;
-  void stderr_error_log(const char *function_name, const char *message) const;
-  void stderr_error_log(const char *function_name,
-                        const std::string &message) const;
+  explicit Logger(std::string system_name) : system_name(std::move(system_name)) {}
 };
 
 #endif // LOGGING_H
+
+#pragma clang diagnostic pop

package/src/logging_napi.cc

@@ -1,14 +1,17 @@
 #include "logging_napi.h"
 #include "napi_utils.h"
 
-LoggerNapi::LoggerNapi(Napi::Env &env, std::string system_name)
-    : Logger(system_name), log_hook(Napi::FunctionReference()), env(env) {}
+LoggerNapi::LoggerNapi(Napi::Env &env, const std::string &system_name)
+    : StdErrLogger(system_name), log_hook(Napi::FunctionReference()), env(env) {
+}
 
-LoggerNapi::LoggerNapi(Napi::Env &env, std::string system_name,
-                       Napi::Function new_log_hook)
-    : Logger(system_name), env(env) {
+[[maybe_unused]] LoggerNapi::LoggerNapi(Napi::Env &env,
+                                        const std::string &system_name,
+                                        Napi::Function new_log_hook)
+    : StdErrLogger(system_name), env(env) {
   if (unlikely(new_log_hook.IsEmpty())) {
-    NapiUtils::ThrowException(env, system_name + ": new_log_hook cannot be nullptr");
+    NapiUtils::ThrowException(env,
+                              system_name + ": new_log_hook cannot be nullptr");
   }
   log_hook = Napi::Persistent(new_log_hook);
 }
@@ -22,7 +25,8 @@ LoggerNapi::~LoggerNapi() {
 
 void LoggerNapi::set_log_hook(Napi::Function new_log_hook) {
   if (unlikely(new_log_hook.IsUndefined() || new_log_hook.IsEmpty())) {
-    NapiUtils::ThrowException(env, system_name + ": new_log_hook cannot be empty");
+    NapiUtils::ThrowException(env,
+                              system_name + ": new_log_hook cannot be empty");
   }
   auto old_log_hook = std::exchange(log_hook, Napi::Persistent(new_log_hook));
   if (!old_log_hook.IsEmpty()) {
@@ -36,17 +40,19 @@ void LoggerNapi::call_log_hook(int level, const std::string &message) const {
   }
   Napi::HandleScope scope(env);
   Napi::Function log_hook_function = log_hook.Value();
-  log_hook_function.Call({Napi::Number::New(env, level),
-                          Napi::String::New(env, system_name + ": " + message)});
+  log_hook_function.Call(
+      {Napi::Number::New(env, level),
+       Napi::String::New(env, system_name + ": " + message)});
 }
 
 void LoggerNapi::debug_log(const char *function_name,
                            const char *message) const {
   if (unlikely(verbose_flag)) {
     if (unlikely(log_hook.IsEmpty())) {
-      stderr_debug_log(function_name, message);
+      StdErrLogger::debug_log(function_name, message);
     } else {
-      call_log_hook(posix_log_level_debug, system_name + ": " + function_name + ": " + message);
+      call_log_hook(posix_log_level_debug,
+                    system_name + ": " + function_name + ": " + message);
     }
   }
 }
@@ -55,9 +61,10 @@ void LoggerNapi::debug_log(const char *function_name,
                            const std::string &message) const {
   if (unlikely(verbose_flag)) {
     if (unlikely(log_hook.IsEmpty())) {
-      stderr_debug_log(function_name, message);
+      StdErrLogger::debug_log(function_name, message);
     } else {
-      call_log_hook(posix_log_level_debug, system_name + ": " + function_name + ": " + message);
+      call_log_hook(posix_log_level_debug,
+                    system_name + ": " + function_name + ": " + message);
     }
   }
 }
@@ -67,12 +74,12 @@ void LoggerNapi::debug_log_alloca(const char *function_name,
                                   size_t length) const {
   if (unlikely(verbose_flag)) {
     if (unlikely(log_hook.IsEmpty())) {
-      stderr_debug_log_alloca(function_name, variable_name, length);
+      StdErrLogger::debug_log_alloca(function_name, variable_name, length);
     } else {
-      call_log_hook(posix_log_level_debug, system_name + ": " + function_name +
-                                              ": Calling alloca(" +
-                                              std::to_string(length) +
-                                              ") (stack) for " + variable_name);
+      call_log_hook(posix_log_level_debug,
+                    system_name + ": " + function_name + ": Calling alloca(" +
+                        std::to_string(length) + ") (stack) for " +
+                        variable_name);
     }
   }
 }
@@ -81,12 +88,12 @@ void LoggerNapi::debug_log_new(const char *function_name,
                                const char *variable_name, size_t length) const {
   if (unlikely(verbose_flag)) {
     if (unlikely(log_hook.IsEmpty())) {
-      stderr_debug_log_new(function_name, variable_name, length);
+      StdErrLogger::debug_log_new(function_name, variable_name, length);
     } else {
       call_log_hook(posix_log_level_debug, system_name + ": " + function_name +
-                                              ": Calling new[" +
-                                              std::to_string(length) + "] (heap) for " +
-                                              variable_name);
+                                               ": Calling new[" +
+                                               std::to_string(length) +
+                                               "] (heap) for " + variable_name);
     }
   }
 }
@@ -94,13 +101,15 @@ void LoggerNapi::debug_log_new(const char *function_name,
 void LoggerNapi::error_log(const char *function_name,
                            const char *message) const {
   if (likely(!log_hook.IsEmpty())) {
-    call_log_hook(posix_log_level_error, system_name + ": " + function_name + ": " + message);
+    call_log_hook(posix_log_level_error,
+                  system_name + ": " + function_name + ": " + message);
   }
 }
 
 void LoggerNapi::error_log(const char *function_name,
                            const std::string &message) const {
   if (likely(!log_hook.IsEmpty())) {
-    call_log_hook(posix_log_level_error, system_name + ": " + function_name + ": " + message);
+    call_log_hook(posix_log_level_error,
+                  system_name + ": " + function_name + ": " + message);
   }
 }

package/src/logging_napi.h

@@ -1,18 +1,18 @@
 #ifndef LOGGING_NAPI_H
 #define LOGGING_NAPI_H
+
 #include "hints.h"
 #include "logging.h"
+#include "logging_stderr.h"
 #include <napi.h>
 
-#ifndef NAPI_CPP_EXCEPTIONS
-#error Support for C++ exceptions is required
-#endif
-
-class LoggerNapi : public Logger {
+class LoggerNapi : public StdErrLogger {
 public:
-  LoggerNapi(Napi::Env &env, std::string system_name);
-  explicit LoggerNapi(Napi::Env &env, std::string system_name,
-                      Napi::Function new_log_hook);
+  LoggerNapi(Napi::Env &env, const std::string &system_name);
+
+  [[maybe_unused]] explicit LoggerNapi(Napi::Env &env,
+                                       const std::string &system_name,
+                                       Napi::Function new_log_hook);
   ~LoggerNapi();
 
   void set_log_hook(Napi::Function new_log_hook);

package/src/{logging.cc → logging_stderr.cc}

@@ -1,14 +1,12 @@
-#include "logging.h"
+#include "logging_stderr.h"
 #include "hints.h"
 #include <iostream>
 
-void Logger::set_verbose_flag(int32_t verbose) { verbose_flag = verbose != 0; }
+StdErrLogger::StdErrLogger(const std::string &system_name)
+    : Logger(system_name) {}
 
-Logger::Logger(const std::string &system_name) : system_name(system_name) {
-  std::cerr << "Created logger for " << system_name << std::endl << std::flush;
-}
-
-void Logger::stderr_debug_log(const char *function_name, const char *message) const {
+void StdErrLogger::debug_log(const char *function_name,
+                             const char *message) const {
   if (unlikely(verbose_flag)) {
     std::cerr << system_name << ": [DEBUG] " << function_name << ": " << message
               << std::endl
@@ -16,8 +14,8 @@ void Logger::stderr_debug_log(const char *function_name, const char *message) co
   }
 }
 
-void Logger::stderr_debug_log(const char *function_name,
-                         const std::string &message) const {
+void StdErrLogger::debug_log(const char *function_name,
+                             const std::string &message) const {
   if (unlikely(verbose_flag)) {
     std::cerr << system_name << ": [DEBUG] " << function_name << ": " << message
               << std::endl
@@ -25,8 +23,9 @@ void Logger::stderr_debug_log(const char *function_name,
   }
 }
 
-void Logger::stderr_debug_log_alloca(
-    const char *function_name, const char *variable_name, size_t length) const {
+void StdErrLogger::debug_log_alloca(const char *function_name,
+                                    const char *variable_name,
+                                    size_t length) const {
   if (unlikely(verbose_flag)) {
     std::cerr << system_name << ": [DEBUG] " << function_name
               << ": Calling alloca(" << length << ") (stack) for "
@@ -35,8 +34,9 @@ void Logger::stderr_debug_log_alloca(
   }
 }
 
-void Logger::stderr_debug_log_new(const char *function_name,
-                             const char *variable_name, size_t length) const {
+void StdErrLogger::debug_log_new(const char *function_name,
+                                 const char *variable_name,
+                                 size_t length) const {
   if (unlikely(verbose_flag)) {
     std::cerr << system_name << ": [DEBUG] " << function_name
               << ": Calling new[" << length << "] (heap) for " << variable_name
@@ -45,14 +45,15 @@ void Logger::stderr_debug_log_new(const char *function_name,
   }
 }
 
-void Logger::stderr_error_log(const char *function_name, const char *message) const {
+void StdErrLogger::error_log(const char *function_name,
+                             const char *message) const {
   std::cerr << system_name << ": [ERROR] " << function_name << ": " << message
             << std::endl
             << std::flush;
 }
 
-void Logger::stderr_error_log(const char *function_name,
-                         const std::string &message) const {
+void StdErrLogger::error_log(const char *function_name,
+                             const std::string &message) const {
   std::cerr << system_name << ": [ERROR] " << function_name << ": " << message
             << std::endl
             << std::flush;

package/src/logging_stderr.h

@@ -0,0 +1,23 @@
+#ifndef STDERR_LOGGER_H
+#define STDERR_LOGGER_H
+
+#include "logging.h"
+
+class StdErrLogger : public Logger {
+public:
+  StdErrLogger() = delete;
+  explicit StdErrLogger(const std::string &system_name);
+
+  void debug_log(const char *function_name, const char *message) const override;
+  void debug_log(const char *function_name,
+                 const std::string &message) const override;
+  void debug_log_alloca(const char *function_name, const char *variable_name,
+                        size_t length) const override;
+  void debug_log_new(const char *function_name, const char *variable_name,
+                     size_t length) const override;
+  void error_log(const char *function_name, const char *message) const override;
+  void error_log(const char *function_name,
+                 const std::string &message) const override;
+};
+
+#endif // STDERR_LOGGER_H

package/src/napi_utils.h

@@ -5,9 +5,6 @@
 #include <napi.h>
 #include <stdexcept>
 #include <string>
-#ifndef NAPI_CPP_EXCEPTIONS
-#error Support for C++ exceptions is required
-#endif
 
 class NapiUtils {
 public:
@@ -26,7 +23,7 @@ public:
 
   [[noreturn]] static void ThrowException(const Napi::Env &env,
                                           const std::string &message) {
-    //throw std::runtime_error(message);
+    // throw std::runtime_error(message);
     throw Napi::Error::New(env, message);
   }
 
@@ -41,12 +38,12 @@ public:
       ThrowException(env, "Input value is undefined");
     } else if (value.IsString()) {
       // Convert string to object using JSON.parse
-      Napi::String str = value.As<Napi::String>();
+      auto str = value.As<Napi::String>();
       jsonString = str;
       jsonObject = jsonParse.Call({str}).As<Napi::Object>();
     } else if (value.IsObject()) {
       // Convert object to string using JSON.stringify
-      Napi::Object obj = value.As<Napi::Object>();
+        auto obj = value.As<Napi::Object>();
       if (jsonStringify.IsUndefined()) {
         ThrowException(env, "jsonStringify is undefined");
       } else if (jsonStringify.IsEmpty()) {
@@ -114,25 +111,31 @@ public:
     if (likely(value.IsString())) {
       return value.As<Napi::String>();
     } else if (unlikely(value.IsUndefined())) {
-      ThrowException(env, std::string(func_name) + ": Expected String but received undefined");
+      ThrowException(env, std::string(func_name) +
+                              ": Expected String but received undefined");
     } else if (unlikely(value.IsNull())) {
-      ThrowException(env, std::string(func_name) + ": Expected String but received null");
+      ThrowException(env, std::string(func_name) +
+                              ": Expected String but received null");
     } else {
-      ThrowException(env, std::string(func_name) + ": Expected String but received unknown type");
+      ThrowException(env, std::string(func_name) +
+                              ": Expected String but received unknown type");
     }
   }
 
-    __attribute__((unused)) static Napi::Buffer<unsigned char>
+  __attribute__((unused)) static Napi::Buffer<unsigned char>
   RequireParameterBuffer(const Napi::Env &env, const char *func_name,
                          Napi::Value value) {
     if (likely(value.IsBuffer())) {
       return value.As<Napi::Buffer<unsigned char>>();
     } else if (unlikely(value.IsUndefined())) {
-      ThrowException(env, std::string(func_name) + ": Expected String but received undefined");
+      ThrowException(env, std::string(func_name) +
+                              ": Expected String but received undefined");
     } else if (unlikely(value.IsNull())) {
-      ThrowException(env, std::string(func_name) + ": Expected String but received null");
+      ThrowException(env, std::string(func_name) +
+                              ": Expected String but received null");
     } else {
-      ThrowException(env, std::string(func_name) + ": Expected String but received unknown type");
+      ThrowException(env, std::string(func_name) +
+                              ": Expected String but received unknown type");
     }
   }
 
@@ -144,11 +147,14 @@ public:
     } else if (likely(value.IsBuffer())) {
       return value.As<Napi::Buffer<unsigned char>>(); // NOLINT(*-slicing)
     } else if (unlikely(value.IsUndefined())) {
-      ThrowException(env, std::string(func_name) + ": Expected String but received undefined");
+      ThrowException(env, std::string(func_name) +
+                              ": Expected String but received undefined");
     } else if (unlikely(value.IsNull())) {
-      ThrowException(env, std::string(func_name) + ": Expected String but received null");
+      ThrowException(env, std::string(func_name) +
+                              ": Expected String but received null");
     } else {
-      ThrowException(env, std::string(func_name) + ": Expected String but received unknown type");
+      ThrowException(env, std::string(func_name) +
+                              ": Expected String but received unknown type");
     }
   }
 

package/src/scoped_allocate.h

@@ -1,6 +1,8 @@
 #ifndef SCOPED_ALLOCATE_H
 #define SCOPED_ALLOCATE_H
 
+#ifdef USE_SCOPED_ALLOCATE_BUFFER
+
 /*
   This macro allows us to allocate a buffer either on the stack or on the heap.
   If the requested buffer size is less than max_stack_alloc_size, we create the
@@ -13,36 +15,36 @@
   will automatically free the allocated buffer when it goes out of scope.
 */
 
-#define SCOPED_ALLOCATE_BUFFER_UNIQUE_PTR(logger, buffer, buffer_size,         \
-                                          unique_ptr, max_stack_alloc_size,    \
-                                          function_name)                       \
+#define SCOPED_ALLOCATE_BUFFER_UNIQUE_PTR(buffer, buffer_size, unique_ptr,     \
+                                          max_stack_alloc_size, function_name) \
   do {                                                                         \
     buffer = nullptr;                                                          \
     if (buffer_size < max_stack_alloc_size) {                                  \
       /* If the buffer is small enough, allocate it on the stack */            \
-      logger.debug_log_alloca(function_name, #buffer, buffer_size);            \
       buffer = (char *)alloca(buffer_size);                                    \
-      throw std::runtime_error("alloca(" + std::to_string(buffer_size) +       \
-                               ") returned null");                             \
+      if (unlikely(buffer == nullptr)) {                                       \
+        throw std::runtime_error(std::string(function_name) + " alloca(" +     \
+                                 std::to_string(buffer_size) +                 \
+                                 ") returned null");                           \
+      }                                                                        \
     } else {                                                                   \
       /* Otherwise, allocate it on the heap */                                 \
-      logger.debug_log_new(function_name, #buffer, buffer_size);               \
       buffer = new (std::nothrow) char[buffer_size];                           \
       if (unlikely(buffer == nullptr)) {                                       \
-        std::string error_msg = std::string(function_name) + "new[" +          \
-                                std::to_string(buffer_size) +                  \
-                                "] returned null";                             \
-        throw std::runtime_error(error_msg);                                   \
+        throw std::runtime_error(std::string(function_name) + " new[" +        \
+                                 std::to_string(buffer_size) +                 \
+                                 "] returned null");                           \
       }                                                                        \
       unique_ptr.reset(buffer);                                                \
     }                                                                          \
   } while (0)
 
-#define SCOPED_ALLOCATE_BUFFER(logger, buffer, buffer_size,                    \
-                               max_stack_alloc_size, function_name)            \
+#define SCOPED_ALLOCATE_BUFFER(buffer, buffer_size, max_stack_alloc_size,      \
+                               function_name)                                  \
   std::unique_ptr<char[]> buffer##_unique_ptr;                                 \
-  SCOPED_ALLOCATE_BUFFER_UNIQUE_PTR(logger, buffer, buffer_size,               \
-                                    buffer##_unique_ptr, max_stack_alloc_size, \
-                                    function_name)
+  SCOPED_ALLOCATE_BUFFER_UNIQUE_PTR(buffer, buffer_size, buffer##_unique_ptr,  \
+                                    max_stack_alloc_size, function_name)
+
+#endif // USE_SCOPED_ALLOCATE_BUFFER
 
 #endif // SCOPED_ALLOCATE_H