add more code

Author: baileympearson

index.js

@@ -3,14 +3,25 @@ const { compress: _compress, decompress: _decompress } = require('bindings')('zs
 // Error objects created via napi don't have JS stacks; wrap them so .stack is present
 // https://github.com/nodejs/node/issues/25318#issuecomment-451068073
 
-exports.compress = async function compress(data) {
+exports.compress = async function compress(data, compressionLevel) {
+  if (!Buffer.isBuffer(data)) {
+    throw new TypeError(`parameter 'data' must be a Buffer.`);
+  }
+
+  if (compressionLevel != null && typeof compressionLevel !== 'number') {
+    throw new TypeError(`parameter 'compressionLevel' must be a number.`);
+  }
+
   try {
-    return await _compress(data);
+    return await _compress(data, compressionLevel ?? 3);
   } catch (e) {
     throw new Error(`zstd: ${e.message}`);
   }
 };
 exports.decompress = async function decompress(data) {
+  if (!Buffer.isBuffer(data)) {
+    throw new TypeError(`parameter 'data' must be a Buffer.`);
+  }
   try {
     return await _decompress(data);
   } catch (e) {

src/addon.cpp

@@ -4,39 +4,23 @@
 #include <vector>
 
 #include "compression_worker.h"
-#include "napi_utils.h"
 #include "compressor.h"
 #include "decompressor.h"
-
+#include "napi_utils.h"
 #include "zstd.h"
 
 using namespace Napi;
 
 Napi::Promise Compress(const Napi::CallbackInfo& info) {
-    auto number_of_args = info.Length();
-    size_t compression_level;
-    Napi::Uint8Array to_compress;
-
-    if (number_of_args == 0) {
-        std::string error_message =
-            "compress(uint8array) or compress(uint8array, compression level)";
-        throw TypeError::New(info.Env(), error_message);
-    } else if (number_of_args == 1) {
-        to_compress = Uint8ArrayFromValue(info[0], "buffer");
-        compression_level = 3;
-    } else if (number_of_args == 2) {
-        to_compress = Uint8ArrayFromValue(info[0], "buffer");
-        if (!info[1].IsNumber()) {
-            throw TypeError::New(info.Env(),
-                                 std::string("if provided, compression_level must be a number."));
-        }
-        compression_level = (size_t)info[1].ToNumber().Int32Value();
-    } else {
-        std::string error_message =
-            "compress(uint8array) or compress(uint8array, compression level)";
+    // Argument handling happens in JS
+    if (info.Length() != 2) {
+        std::string error_message = "Expected two arguments.";
         throw TypeError::New(info.Env(), error_message);
     }
 
+    Uint8Array to_compress = Uint8ArrayFromValue(info[0], "buffer");
+    size_t compression_level = (size_t)info[1].ToNumber().Int32Value();
+
     Compressor compressor = Compressor::fromUint8Array(to_compress, compression_level);
     Worker<Compressor>* worker = new Worker<Compressor>(info.Env(), std::move(compressor));
 
@@ -46,19 +30,13 @@ Napi::Promise Compress(const Napi::CallbackInfo& info) {
 }
 
 Napi::Promise Decompress(const CallbackInfo& info) {
-    auto number_of_args = info.Length();
-    Napi::Uint8Array compressed_data;
-
-    if (number_of_args == 0) {
-        std::string error_message = "decompress(uint8array)";
-        throw TypeError::New(info.Env(), error_message);
-    } else if (number_of_args == 1) {
-        compressed_data = Uint8ArrayFromValue(info[0], "buffer");
-    } else {
-        std::string error_message = "decompress(uint8array)";
+    // Argument handling happens in JS
+    if (info.Length() != 1) {
+        std::string error_message = "Expected one argument.";
         throw TypeError::New(info.Env(), error_message);
     }
 
+    Napi::Uint8Array compressed_data = Uint8ArrayFromValue(info[0], "buffer");
     Decompressor decompressor = Decompressor::fromUint8Array(compressed_data);
     Worker<Decompressor>* worker = new Worker<Decompressor>(info.Env(), decompressor);
 

src/compression_worker.h

@@ -5,8 +5,9 @@
 using namespace Napi;
 
 /**
- * @brief A class that represents the result of a compression operation.  Once the MACOS_DEPLOYMENT_TARGET can be raised to 10.13 and use 
- * a c++17, we can remove this class and use a std::optional<std::variant<std::vector<uint8_t>, std::string>>> instead.
+ * @brief A class that represents the result of a compression operation.  Once the
+ * MACOS_DEPLOYMENT_TARGET can be raised to 10.13 and use a c++17, we can remove this class and use
+ * a std::optional<std::variant<std::vector<uint8_t>, std::string>>> instead.
  */
 struct CompressionResult {
     CompressionResult(std::string error,
@@ -42,8 +43,9 @@ struct CompressionResult {
 };
 
 /**
- * @brief An asynchronous Napi::Worker that can be with any functor that produces CompressionResults.
- * 
+ * @brief An asynchronous Napi::Worker that can be with any functor that produces
+ * CompressionResults.
+ *
  * @tparam TWorker - The functor to call asynchronously.
  */
 template <typename TWorker>
@@ -66,22 +68,22 @@ class Worker : public Napi::AsyncWorker {
 
     void OnOK() {
         if (!result.initialized) {
-            m_deferred.Reject(
-                Napi::Error::New(
-                    Env(), "zstd runtime error - async worker finished without a compression or decompression result.")
-                    .Value());
+            m_deferred.Reject(Napi::Error::New(Env(),
+                                               "zstd runtime error - async worker finished without "
+                                               "a compression or decompression result.")
+                                  .Value());
         } else if (result.hasError) {
             m_deferred.Reject(Napi::Error::New(Env(), result.error).Value());
         } else if (result.hasResult) {
-            Uint8Array output = Uint8Array::New(m_deferred.Env(), result.result.size());
-            std::copy(result.result.begin(), result.result.end(), output.Data());
+            Buffer<uint8_t> output =
+                Buffer<uint8_t>::Copy(m_deferred.Env(), result.result.data(), result.result.size());
 
             m_deferred.Resolve(output);
         } else {
-            m_deferred.Reject(
-            Napi::Error::New(
-                Env(), "zstd runtime error - async worker finished without a compression or decompression result.")
-                .Value());
+            m_deferred.Reject(Napi::Error::New(Env(),
+                                               "zstd runtime error - async worker finished without "
+                                               "a compression or decompression result.")
+                                  .Value());
         }
     }
 

src/compressor.h

@@ -1,7 +1,8 @@
 
-#include <vector>
 #include <napi.h>
 
+#include <vector>
+
 #include "zstd.h"
 
 using namespace Napi;

src/decompressor.h

@@ -2,8 +2,6 @@
 
 #include <vector>
 
-
-
 #include "zstd.h"
 
 using namespace Napi;

src/napi_utils.h

@@ -3,7 +3,7 @@
 using namespace Napi;
 
 /**
- * @brief Given a T* source and a T* destination, copies count 
+ * @brief Given a T* source and a T* destination, copies count
  * elements from source into destination.
  */
 template <typename T>
@@ -14,12 +14,12 @@ void copy_buffer_data(T* source, T* dest, size_t count) {
 }
 
 /**
- * @brief Given an Napi;:Value, this function returns the value as a Uint8Array, if the 
+ * @brief Given an Napi;:Value, this function returns the value as a Uint8Array, if the
  * Value is a Uint8Array. Otherwise, this function throws.
- * 
+ *
  * @param v - An Napi::Value
  * @param argument_name - the name of the value, to use when constructing an error message.
- * @return Napi::Uint8Array 
+ * @return Napi::Uint8Array
  */
 Uint8Array Uint8ArrayFromValue(Value v, std::string argument_name) {
     if (!v.IsTypedArray() || v.As<TypedArray>().TypedArrayType() != napi_uint8_array) {

test/index.test.js

@@ -1,14 +1,37 @@
 const { describe, test } = require('mocha');
-const { compress, decompress } = require('bindings')('zstd');
+const { compress, decompress } = require('../index');
 
 const zstdLegacy = require('@mongodb-js/zstd');
 const { expect } = require('chai');
 
+describe('compat tests', function () {
+  describe('old compress, new decompress', testSuite(zstdLegacy.decompress, compress));
+  describe('new compress, decompress', testSuite(decompress, zstdLegacy.compress));
+  describe('new compress, new decompress', testSuite(decompress, compress));
+});
+
+describe('decompress', function () {
+  test('decompress() throws a TypeError', async function () {
+    expect(await decompress().catch(e => e))
+      .to.be.instanceOf(TypeError)
+      .to.match(/must be a buffer/i);
+  });
+
+  test('decompress() returns a Nodejs buffer', async function () {
+    const compressed = await zstdLegacy.compress(Buffer.from([1, 2, 3]));
+    expect(await decompress(compressed)).to.be.instanceOf(Buffer);
+  });
+});
+
 describe('compress', function () {
-  describe('compat tests', function () {
-    describe('old compress, new decompress', testSuite(zstdLegacy.decompress, compress));
-    describe('new compress, decompress', testSuite(decompress, zstdLegacy.compress));
-    describe('new compress, new decompress', testSuite(decompress, compress));
+  test('compress() throws a TypeError', async function () {
+    expect(await compress().catch(e => e))
+      .to.be.instanceOf(TypeError)
+      .to.match(/must be a buffer/i);
+  });
+
+  test('compress() returns a Nodejs buffer', async function () {
+    expect(await compress(Buffer.from([1, 2, 3]))).to.be.instanceOf(Buffer);
   });
 });