pulsar-client 1.0.0 → 1.1.1

package/README.md

@@ -43,6 +43,7 @@ Compatibility between each version of the Node.js client and the C++ client is a
 | Node.js client | C++ client     |
 |----------------|----------------|
 | 1.0.0          | 2.3.0 or later |
+| 1.1.0          | 2.4.0 or later |
 
 If an incompatible version of the C++ client is installed, you may fail to build or run this library.
 
@@ -54,6 +55,12 @@ If an incompatible version of the C++ client is installed, you may fail to build
 $ npm install pulsar-client
 ```
 
+## Typescript Definitions
+
+```shell
+$ npm install @types/pulsar-client --save-dev
+```
+
 ## Sample code
 
 Please refer to [examples](https://github.com/apache/pulsar-client-node/tree/master/examples).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulsar-client",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Pulsar Node.js client",
   "main": "index.js",
   "directories": {
@@ -27,7 +27,7 @@
   "license": "Apache-2.0",
   "gypfile": true,
   "engines": {
-    "node": ">=10.0.0"
+    "node": ">=10.16.0"
   },
   "devDependencies": {
     "clang-format": "^1.2.4",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "bindings": "^1.3.1",
-    "node-addon-api": "^1.6.2",
+    "node-addon-api": "^2.0.0",
     "node-gyp": "^3.8.0",
     "node-pre-gyp": "^0.12.0"
   },

package/src/Consumer.cc

@@ -34,6 +34,8 @@ void Consumer::Init(Napi::Env env, Napi::Object exports) {
                       InstanceMethod("receive", &Consumer::Receive),
                       InstanceMethod("acknowledge", &Consumer::Acknowledge),
                       InstanceMethod("acknowledgeId", &Consumer::AcknowledgeId),
+                      InstanceMethod("negativeAcknowledge", &Consumer::NegativeAcknowledge),
+                      InstanceMethod("negativeAcknowledgeId", &Consumer::NegativeAcknowledgeId),
                       InstanceMethod("acknowledgeCumulative", &Consumer::AcknowledgeCumulative),
                       InstanceMethod("acknowledgeCumulativeId", &Consumer::AcknowledgeCumulativeId),
                       InstanceMethod("close", &Consumer::Close),
@@ -43,18 +45,20 @@ void Consumer::Init(Napi::Env env, Napi::Object exports) {
   constructor.SuppressDestruct();
 }
 
-void Consumer::SetCConsumer(pulsar_consumer_t *cConsumer) { this->cConsumer = cConsumer; }
+void Consumer::SetCConsumer(std::shared_ptr<CConsumerWrapper> cConsumer) { this->wrapper = cConsumer; }
+void Consumer::SetListenerCallback(ListenerCallback *listener) { this->listener = listener; }
 
-Consumer::Consumer(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Consumer>(info) {}
+Consumer::Consumer(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Consumer>(info), listener(nullptr) {}
 
 class ConsumerNewInstanceWorker : public Napi::AsyncWorker {
  public:
   ConsumerNewInstanceWorker(const Napi::Promise::Deferred &deferred, pulsar_client_t *cClient,
-                            ConsumerConfig *consumerConfig)
+                            ConsumerConfig *consumerConfig, std::shared_ptr<CConsumerWrapper> consumerWrapper)
       : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
         deferred(deferred),
         cClient(cClient),
-        consumerConfig(consumerConfig) {}
+        consumerConfig(consumerConfig),
+        consumerWrapper(consumerWrapper) {}
   ~ConsumerNewInstanceWorker() {}
   void Execute() {
     const std::string &topic = this->consumerConfig->GetTopic();
@@ -75,20 +79,29 @@ class ConsumerNewInstanceWorker : public Napi::AsyncWorker {
       SetError(msg);
       return;
     }
+    int32_t nAckRedeliverTimeoutMs = this->consumerConfig->GetNAckRedeliverTimeoutMs();
+    if (nAckRedeliverTimeoutMs < 0) {
+      std::string msg("NAck timeout should be greater than or equal to zero");
+      SetError(msg);
+      return;
+    }
 
-    pulsar_result result =
-        pulsar_client_subscribe(this->cClient, topic.c_str(), subscription.c_str(),
-                                this->consumerConfig->GetCConsumerConfig(), &(this->cConsumer));
-    delete this->consumerConfig;
+    pulsar_result result = pulsar_client_subscribe(this->cClient, topic.c_str(), subscription.c_str(),
+                                                   this->consumerConfig->GetCConsumerConfig(),
+                                                   &this->consumerWrapper->cConsumer);
     if (result != pulsar_result_Ok) {
       SetError(std::string("Failed to create consumer: ") + pulsar_result_str(result));
-      return;
+    } else {
+      this->listener = this->consumerConfig->GetListenerCallback();
     }
+
+    delete this->consumerConfig;
   }
   void OnOK() {
     Napi::Object obj = Consumer::constructor.New({});
     Consumer *consumer = Consumer::Unwrap(obj);
-    consumer->SetCConsumer(this->cConsumer);
+    consumer->SetCConsumer(this->consumerWrapper);
+    consumer->SetListenerCallback(this->listener);
     this->deferred.Resolve(obj);
   }
   void OnError(const Napi::Error &e) { this->deferred.Reject(Napi::Error::New(Env(), e.Message()).Value()); }
@@ -96,15 +109,19 @@ class ConsumerNewInstanceWorker : public Napi::AsyncWorker {
  private:
   Napi::Promise::Deferred deferred;
   pulsar_client_t *cClient;
-  ConsumerConfig *consumerConfig;
   pulsar_consumer_t *cConsumer;
+  ConsumerConfig *consumerConfig;
+  ListenerCallback *listener;
+  std::shared_ptr<CConsumerWrapper> consumerWrapper;
 };
 
 Napi::Value Consumer::NewInstance(const Napi::CallbackInfo &info, pulsar_client_t *cClient) {
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
   Napi::Object config = info[0].As<Napi::Object>();
-  ConsumerConfig *consumerConfig = new ConsumerConfig(config);
-  ConsumerNewInstanceWorker *wk = new ConsumerNewInstanceWorker(deferred, cClient, consumerConfig);
+  std::shared_ptr<CConsumerWrapper> consumerWrapper = std::make_shared<CConsumerWrapper>();
+  ConsumerConfig *consumerConfig = new ConsumerConfig(config, consumerWrapper);
+  ConsumerNewInstanceWorker *wk =
+      new ConsumerNewInstanceWorker(deferred, cClient, consumerConfig, consumerWrapper);
   wk->Queue();
   return deferred.Promise();
 }
@@ -146,11 +163,12 @@ class ConsumerReceiveWorker : public Napi::AsyncWorker {
 Napi::Value Consumer::Receive(const Napi::CallbackInfo &info) {
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
   if (info[0].IsUndefined()) {
-    ConsumerReceiveWorker *wk = new ConsumerReceiveWorker(deferred, this->cConsumer);
+    ConsumerReceiveWorker *wk = new ConsumerReceiveWorker(deferred, this->wrapper->cConsumer);
     wk->Queue();
   } else {
     Napi::Number timeout = info[0].As<Napi::Object>().ToNumber();
-    ConsumerReceiveWorker *wk = new ConsumerReceiveWorker(deferred, this->cConsumer, timeout.Int64Value());
+    ConsumerReceiveWorker *wk =
+        new ConsumerReceiveWorker(deferred, this->wrapper->cConsumer, timeout.Int64Value());
     wk->Queue();
   }
   return deferred.Promise();
@@ -159,25 +177,38 @@ Napi::Value Consumer::Receive(const Napi::CallbackInfo &info) {
 void Consumer::Acknowledge(const Napi::CallbackInfo &info) {
   Napi::Object obj = info[0].As<Napi::Object>();
   Message *msg = Message::Unwrap(obj);
-  pulsar_consumer_acknowledge_async(this->cConsumer, msg->GetCMessage(), NULL, NULL);
+  pulsar_consumer_acknowledge_async(this->wrapper->cConsumer, msg->GetCMessage(), NULL, NULL);
 }
 
 void Consumer::AcknowledgeId(const Napi::CallbackInfo &info) {
   Napi::Object obj = info[0].As<Napi::Object>();
   MessageId *msgId = MessageId::Unwrap(obj);
-  pulsar_consumer_acknowledge_async_id(this->cConsumer, msgId->GetCMessageId(), NULL, NULL);
+  pulsar_consumer_acknowledge_async_id(this->wrapper->cConsumer, msgId->GetCMessageId(), NULL, NULL);
+}
+
+void Consumer::NegativeAcknowledge(const Napi::CallbackInfo &info) {
+  Napi::Object obj = info[0].As<Napi::Object>();
+  Message *msg = Message::Unwrap(obj);
+  pulsar_consumer_negative_acknowledge(this->wrapper->cConsumer, msg->GetCMessage());
+}
+
+void Consumer::NegativeAcknowledgeId(const Napi::CallbackInfo &info) {
+  Napi::Object obj = info[0].As<Napi::Object>();
+  MessageId *msgId = MessageId::Unwrap(obj);
+  pulsar_consumer_negative_acknowledge_id(this->wrapper->cConsumer, msgId->GetCMessageId());
 }
 
 void Consumer::AcknowledgeCumulative(const Napi::CallbackInfo &info) {
   Napi::Object obj = info[0].As<Napi::Object>();
   Message *msg = Message::Unwrap(obj);
-  pulsar_consumer_acknowledge_cumulative_async(this->cConsumer, msg->GetCMessage(), NULL, NULL);
+  pulsar_consumer_acknowledge_cumulative_async(this->wrapper->cConsumer, msg->GetCMessage(), NULL, NULL);
 }
 
 void Consumer::AcknowledgeCumulativeId(const Napi::CallbackInfo &info) {
   Napi::Object obj = info[0].As<Napi::Object>();
   MessageId *msgId = MessageId::Unwrap(obj);
-  pulsar_consumer_acknowledge_cumulative_async_id(this->cConsumer, msgId->GetCMessageId(), NULL, NULL);
+  pulsar_consumer_acknowledge_cumulative_async_id(this->wrapper->cConsumer, msgId->GetCMessageId(), NULL,
+                                                  NULL);
 }
 
 class ConsumerCloseWorker : public Napi::AsyncWorker {
@@ -188,6 +219,7 @@ class ConsumerCloseWorker : public Napi::AsyncWorker {
         cConsumer(cConsumer) {}
   ~ConsumerCloseWorker() {}
   void Execute() {
+    pulsar_consumer_pause_message_listener(this->cConsumer);
     pulsar_result result = pulsar_consumer_close(this->cConsumer);
     if (result != pulsar_result_Ok) SetError(pulsar_result_str(result));
   }
@@ -204,9 +236,14 @@ class ConsumerCloseWorker : public Napi::AsyncWorker {
 
 Napi::Value Consumer::Close(const Napi::CallbackInfo &info) {
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  ConsumerCloseWorker *wk = new ConsumerCloseWorker(deferred, this->cConsumer);
+  ConsumerCloseWorker *wk = new ConsumerCloseWorker(deferred, this->wrapper->cConsumer);
   wk->Queue();
   return deferred.Promise();
 }
 
-Consumer::~Consumer() { pulsar_consumer_free(this->cConsumer); }
+Consumer::~Consumer() {
+  if (this->listener) {
+    pulsar_consumer_pause_message_listener(this->wrapper->cConsumer);
+    this->listener->callback.Release();
+  }
+}

package/src/Consumer.h

@@ -22,6 +22,7 @@
 
 #include <napi.h>
 #include <pulsar/c/client.h>
+#include "ConsumerConfig.h"
 
 class Consumer : public Napi::ObjectWrap<Consumer> {
  public:
@@ -30,14 +31,18 @@ class Consumer : public Napi::ObjectWrap<Consumer> {
   static Napi::FunctionReference constructor;
   Consumer(const Napi::CallbackInfo &info);
   ~Consumer();
-  void SetCConsumer(pulsar_consumer_t *cConsumer);
+  void SetCConsumer(std::shared_ptr<CConsumerWrapper> cConsumer);
+  void SetListenerCallback(ListenerCallback *listener);
 
  private:
-  pulsar_consumer_t *cConsumer;
+  std::shared_ptr<CConsumerWrapper> wrapper;
+  ListenerCallback *listener;
 
   Napi::Value Receive(const Napi::CallbackInfo &info);
   void Acknowledge(const Napi::CallbackInfo &info);
   void AcknowledgeId(const Napi::CallbackInfo &info);
+  void NegativeAcknowledge(const Napi::CallbackInfo &info);
+  void NegativeAcknowledgeId(const Napi::CallbackInfo &info);
   void AcknowledgeCumulative(const Napi::CallbackInfo &info);
   void AcknowledgeCumulativeId(const Napi::CallbackInfo &info);
   Napi::Value Close(const Napi::CallbackInfo &info);

package/src/ConsumerConfig.cc

@@ -18,25 +18,65 @@
  */
 
 #include "ConsumerConfig.h"
+#include "Consumer.h"
+#include "Message.h"
 #include <pulsar/c/consumer_configuration.h>
+#include <pulsar/c/consumer.h>
 #include <map>
 
 static const std::string CFG_TOPIC = "topic";
 static const std::string CFG_SUBSCRIPTION = "subscription";
 static const std::string CFG_SUBSCRIPTION_TYPE = "subscriptionType";
+static const std::string CFG_INIT_POSITION = "subscriptionInitialPosition";
 static const std::string CFG_ACK_TIMEOUT = "ackTimeoutMs";
+static const std::string CFG_NACK_REDELIVER_TIMEOUT = "nAckRedeliverTimeoutMs";
 static const std::string CFG_RECV_QUEUE = "receiverQueueSize";
 static const std::string CFG_RECV_QUEUE_ACROSS_PARTITIONS = "receiverQueueSizeAcrossPartitions";
 static const std::string CFG_CONSUMER_NAME = "consumerName";
 static const std::string CFG_PROPS = "properties";
+static const std::string CFG_LISTENER = "listener";
 
 static const std::map<std::string, pulsar_consumer_type> SUBSCRIPTION_TYPE = {
     {"Exclusive", pulsar_ConsumerExclusive},
     {"Shared", pulsar_ConsumerShared},
     {"Failover", pulsar_ConsumerFailover}};
 
-ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig)
-    : topic(""), subscription(""), ackTimeoutMs(0) {
+static const std::map<std::string, initial_position> INIT_POSITION = {
+    {"Latest", initial_position_latest}, {"Earliest", initial_position_earliest}};
+
+struct MessageListenerProxyData {
+  std::shared_ptr<CConsumerWrapper> consumerWrapper;
+  pulsar_message_t *cMessage;
+
+  MessageListenerProxyData(std::shared_ptr<CConsumerWrapper> consumerWrapper, pulsar_message_t *cMessage)
+      : consumerWrapper(consumerWrapper), cMessage(cMessage) {}
+};
+
+void MessageListenerProxy(Napi::Env env, Napi::Function jsCallback, MessageListenerProxyData *data) {
+  Napi::Object msg = Message::NewInstance({}, data->cMessage);
+  Napi::Object consumerObj = Consumer::constructor.New({});
+  Consumer *consumer = Consumer::Unwrap(consumerObj);
+  consumer->SetCConsumer(std::move(data->consumerWrapper));
+  delete data;
+  jsCallback.Call({msg, consumerObj});
+}
+
+void MessageListener(pulsar_consumer_t *cConsumer, pulsar_message_t *cMessage, void *ctx) {
+  ListenerCallback *listenerCallback = (ListenerCallback *)ctx;
+  if (listenerCallback->callback.Acquire() != napi_ok) {
+    return;
+  };
+  MessageListenerProxyData *dataPtr =
+      new MessageListenerProxyData(listenerCallback->consumerWrapper, cMessage);
+  listenerCallback->callback.BlockingCall(dataPtr, MessageListenerProxy);
+  listenerCallback->callback.Release();
+}
+
+void FinalizeListenerCallback(Napi::Env env, ListenerCallback *cb, void *) { delete cb; }
+
+ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
+                               std::shared_ptr<CConsumerWrapper> consumerWrapper)
+    : topic(""), subscription(""), ackTimeoutMs(0), nAckRedeliverTimeoutMs(60000), listener(nullptr) {
   this->cConsumerConfig = pulsar_consumer_configuration_create();
 
   if (consumerConfig.Has(CFG_TOPIC) && consumerConfig.Get(CFG_TOPIC).IsString()) {
@@ -55,6 +95,14 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig)
     }
   }
 
+  if (consumerConfig.Has(CFG_INIT_POSITION) && consumerConfig.Get(CFG_INIT_POSITION).IsString()) {
+    std::string initPosition = consumerConfig.Get(CFG_INIT_POSITION).ToString().Utf8Value();
+    if (INIT_POSITION.count(initPosition)) {
+      pulsar_consumer_set_subscription_initial_position(this->cConsumerConfig,
+                                                        INIT_POSITION.at(initPosition));
+    }
+  }
+
   if (consumerConfig.Has(CFG_CONSUMER_NAME) && consumerConfig.Get(CFG_CONSUMER_NAME).IsString()) {
     std::string consumerName = consumerConfig.Get(CFG_CONSUMER_NAME).ToString().Utf8Value();
     if (!consumerName.empty()) pulsar_consumer_set_consumer_name(this->cConsumerConfig, consumerName.c_str());
@@ -67,6 +115,15 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig)
     }
   }
 
+  if (consumerConfig.Has(CFG_NACK_REDELIVER_TIMEOUT) &&
+      consumerConfig.Get(CFG_NACK_REDELIVER_TIMEOUT).IsNumber()) {
+    this->nAckRedeliverTimeoutMs = consumerConfig.Get(CFG_NACK_REDELIVER_TIMEOUT).ToNumber().Int64Value();
+    if (this->nAckRedeliverTimeoutMs >= 0) {
+      pulsar_configure_set_negative_ack_redelivery_delay_ms(this->cConsumerConfig,
+                                                            this->nAckRedeliverTimeoutMs);
+    }
+  }
+
   if (consumerConfig.Has(CFG_RECV_QUEUE) && consumerConfig.Get(CFG_RECV_QUEUE).IsNumber()) {
     int32_t receiverQueueSize = consumerConfig.Get(CFG_RECV_QUEUE).ToNumber().Int32Value();
     if (receiverQueueSize >= 0) {
@@ -94,12 +151,43 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig)
       pulsar_consumer_configuration_set_property(this->cConsumerConfig, key.c_str(), value.c_str());
     }
   }
+
+  if (consumerConfig.Has(CFG_LISTENER) && consumerConfig.Get(CFG_LISTENER).IsFunction()) {
+    this->listener = new ListenerCallback();
+    this->listener->consumerWrapper = consumerWrapper;
+    Napi::ThreadSafeFunction callback = Napi::ThreadSafeFunction::New(
+        consumerConfig.Env(), consumerConfig.Get(CFG_LISTENER).As<Napi::Function>(), "Listener Callback", 1,
+        1, (void *)NULL, FinalizeListenerCallback, listener);
+    this->listener->callback = std::move(callback);
+    pulsar_consumer_configuration_set_message_listener(this->cConsumerConfig, &MessageListener,
+                                                       this->listener);
+  }
 }
 
-ConsumerConfig::~ConsumerConfig() { pulsar_consumer_configuration_free(this->cConsumerConfig); }
+ConsumerConfig::~ConsumerConfig() {
+  pulsar_consumer_configuration_free(this->cConsumerConfig);
+  if (this->listener) {
+    this->listener->callback.Release();
+  }
+}
 
 pulsar_consumer_configuration_t *ConsumerConfig::GetCConsumerConfig() { return this->cConsumerConfig; }
 
 std::string ConsumerConfig::GetTopic() { return this->topic; }
 std::string ConsumerConfig::GetSubscription() { return this->subscription; }
+ListenerCallback *ConsumerConfig::GetListenerCallback() {
+  ListenerCallback *cb = this->listener;
+  this->listener = nullptr;
+  return cb;
+}
+
 int64_t ConsumerConfig::GetAckTimeoutMs() { return this->ackTimeoutMs; }
+int64_t ConsumerConfig::GetNAckRedeliverTimeoutMs() { return this->nAckRedeliverTimeoutMs; }
+
+CConsumerWrapper::CConsumerWrapper() : cConsumer(nullptr) {}
+
+CConsumerWrapper::~CConsumerWrapper() {
+  if (this->cConsumer) {
+    pulsar_consumer_free(this->cConsumer);
+  }
+}

package/src/ConsumerConfig.h

@@ -25,20 +25,35 @@
 
 #define MIN_ACK_TIMEOUT_MILLIS 10000
 
+struct CConsumerWrapper {
+  pulsar_consumer_t *cConsumer;
+  CConsumerWrapper();
+  ~CConsumerWrapper();
+};
+
+struct ListenerCallback {
+  Napi::ThreadSafeFunction callback;
+  std::shared_ptr<CConsumerWrapper> consumerWrapper;
+};
+
 class ConsumerConfig {
  public:
-  ConsumerConfig(const Napi::Object &consumerConfig);
+  ConsumerConfig(const Napi::Object &consumerConfig, std::shared_ptr<CConsumerWrapper> consumerWrapper);
   ~ConsumerConfig();
   pulsar_consumer_configuration_t *GetCConsumerConfig();
   std::string GetTopic();
   std::string GetSubscription();
   int64_t GetAckTimeoutMs();
+  int64_t GetNAckRedeliverTimeoutMs();
+  ListenerCallback *GetListenerCallback();
 
  private:
   pulsar_consumer_configuration_t *cConsumerConfig;
   std::string topic;
   std::string subscription;
   int64_t ackTimeoutMs;
+  int64_t nAckRedeliverTimeoutMs;
+  ListenerCallback *listener;
 };
 
 #endif

package/src/Message.cc

@@ -181,9 +181,7 @@ pulsar_message_t *Message::BuildMessage(Napi::Object conf) {
       for (int i = 0; i < length; i++) {
         SetString(arr, clusters.Get(i).ToString().Utf8Value().c_str(), i);
       }
-      // TODO: temoporalily commented out unless 2.3.1 which includes interface change of
-      // pulsar_message_set_replication_clusters (#3729) is released
-      // pulsar_message_set_replication_clusters(cMessage, (const char **)arr, length);
+      pulsar_message_set_replication_clusters(cMessage, (const char **)arr, length);
       FreeStringArray(arr, length);
     }
   }

package/src/MessageId.cc

@@ -29,7 +29,7 @@ Napi::Object MessageId::Init(Napi::Env env, Napi::Object exports) {
   Napi::Function func = DefineClass(env, "MessageId",
                                     {StaticMethod("earliest", &MessageId::Earliest, napi_static),
                                      StaticMethod("latest", &MessageId::Latest, napi_static),
-                                     StaticMethod("finalize", &MessageId::Finalize, napi_static),
+                                     StaticMethod("finalize", &MessageId::Free, napi_static),
                                      InstanceMethod("serialize", &MessageId::Serialize),
                                      StaticMethod("deserialize", &MessageId::Deserialize, napi_static),
                                      InstanceMethod("toString", &MessageId::ToString)});
@@ -58,7 +58,7 @@ Napi::Object MessageId::NewInstance(Napi::Value arg) {
   return obj;
 }
 
-void MessageId::Finalize(const Napi::CallbackInfo &info) {
+void MessageId::Free(const Napi::CallbackInfo &info) {
   Napi::Object obj = info[0].As<Napi::Object>();
   MessageId *msgId = Unwrap(obj);
   pulsar_message_id_free(msgId->cMessageId);

package/src/MessageId.h

@@ -33,7 +33,7 @@ class MessageId : public Napi::ObjectWrap<MessageId> {
   static Napi::Value Latest(const Napi::CallbackInfo &info);
   Napi::Value Serialize(const Napi::CallbackInfo &info);
   static Napi::Value Deserialize(const Napi::CallbackInfo &info);
-  static void Finalize(const Napi::CallbackInfo &info);
+  static void Free(const Napi::CallbackInfo &info);
   MessageId(const Napi::CallbackInfo &info);
   ~MessageId();
   pulsar_message_id_t *GetCMessageId();

package/tests/consumer.test.js

@@ -30,6 +30,7 @@ const Pulsar = require('../index.js');
         await expect(client.subscribe({
           subscription: 'sub1',
           ackTimeoutMs: 10000,
+          nAckRedeliverTimeoutMs: 60000,
         })).rejects.toThrow('Topic is required and must be specified as a string when creating consumer');
       });
 
@@ -38,6 +39,7 @@ const Pulsar = require('../index.js');
           topic: 0,
           subscription: 'sub1',
           ackTimeoutMs: 10000,
+          nAckRedeliverTimeoutMs: 60000,
         })).rejects.toThrow('Topic is required and must be specified as a string when creating consumer');
       });
 
@@ -45,6 +47,7 @@ const Pulsar = require('../index.js');
         await expect(client.subscribe({
           topic: 'persistent://public/default/t1',
           ackTimeoutMs: 10000,
+          nAckRedeliverTimeoutMs: 60000,
         })).rejects.toThrow('Subscription is required and must be specified as a string when creating consumer');
       });
 
@@ -53,6 +56,7 @@ const Pulsar = require('../index.js');
           topic: 'persistent://public/default/t1',
           subscription: 0,
           ackTimeoutMs: 10000,
+          nAckRedeliverTimeoutMs: 60000,
         })).rejects.toThrow('Subscription is required and must be specified as a string when creating consumer');
       });
 
@@ -61,6 +65,7 @@ const Pulsar = require('../index.js');
           topic: 'persistent://no-tenant/namespace/topic',
           subscription: 'sub1',
           ackTimeoutMs: 10000,
+          nAckRedeliverTimeoutMs: 60000,
         })).rejects.toThrow('Failed to create consumer: ConnectError');
       });
 
@@ -69,8 +74,18 @@ const Pulsar = require('../index.js');
           topic: 'persistent://public/no-namespace/topic',
           subscription: 'sub1',
           ackTimeoutMs: 10000,
+          nAckRedeliverTimeoutMs: 60000,
         })).rejects.toThrow('Failed to create consumer: ConnectError');
       });
+
+      test('Not Positive NAckRedeliverTimeout', async () => {
+        await expect(client.subscribe({
+          topic: 'persistent://public/default/t1',
+          subscription: 'sub1',
+          ackTimeoutMs: 10000,
+          nAckRedeliverTimeoutMs: -12,
+        })).rejects.toThrow('NAck timeout should be greater than or equal to zero');
+      });
     });
   });
 })();

package/tests/end_to_end.test.js

@@ -67,6 +67,107 @@ const Pulsar = require('../index.js');
       await client.close();
     });
 
+    test('negativeAcknowledge', async () => {
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        operationTimeoutSeconds: 30,
+      });
+
+      const topic = 'persistent://public/default/produce-consume';
+      const producer = await client.createProducer({
+        topic,
+        sendTimeoutMs: 30000,
+        batchingEnabled: true,
+      });
+      expect(producer).not.toBeNull();
+
+      const consumer = await client.subscribe({
+        topic,
+        subscription: 'sub1',
+        ackTimeoutMs: 10000,
+        nAckRedeliverTimeoutMs: 1000,
+      });
+
+      expect(consumer).not.toBeNull();
+
+      const message = 'my-message';
+      producer.send({
+        data: Buffer.from(message),
+      });
+      await producer.flush();
+
+      const results = [];
+      const msg = await consumer.receive();
+      results.push(msg.getData().toString());
+      consumer.negativeAcknowledge(msg);
+
+      const msg2 = await consumer.receive();
+      results.push(msg2.getData().toString());
+      consumer.acknowledge(msg2);
+
+      await expect(consumer.receive(1000)).rejects.toThrow(
+        'Failed to received message TimeOut',
+      );
+
+      expect(results).toEqual([message, message]);
+
+      await producer.close();
+      await consumer.close();
+      await client.close();
+    });
+
+    test('Produce/Consume Listener', async () => {
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        operationTimeoutSeconds: 30,
+      });
+
+      const topic = 'persistent://public/default/produce-consume-listener';
+      const producer = await client.createProducer({
+        topic,
+        sendTimeoutMs: 30000,
+        batchingEnabled: true,
+      });
+      expect(producer).not.toBeNull();
+
+      let finish;
+      const results = [];
+      const finishPromise = new Promise((resolve) => {
+        finish = resolve;
+      });
+
+      const consumer = await client.subscribe({
+        topic,
+        subscription: 'sub1',
+        ackTimeoutMs: 10000,
+        listener: (message, messageConsumer) => {
+          const data = message.getData().toString();
+          results.push(data);
+          messageConsumer.acknowledge(message);
+          if (results.length === 10) finish();
+        },
+      });
+
+      expect(consumer).not.toBeNull();
+
+      const messages = [];
+      for (let i = 0; i < 10; i += 1) {
+        const msg = `my-message-${i}`;
+        producer.send({
+          data: Buffer.from(msg),
+        });
+        messages.push(msg);
+      }
+      await producer.flush();
+
+      await finishPromise;
+      expect(lodash.difference(messages, results)).toEqual([]);
+
+      await producer.close();
+      await consumer.close();
+      await client.close();
+    });
+
     test('acknowledgeCumulative', async () => {
       const client = new Pulsar.Client({
         serviceUrl: 'pulsar://localhost:6650',
@@ -105,13 +206,84 @@ const Pulsar = require('../index.js');
         }
       }
 
-      await expect(consumer.receive(1000)).rejects.toThrow('Failed to received message TimeOut');
+      await expect(consumer.receive(1000)).rejects.toThrow(
+        'Failed to received message TimeOut',
+      );
 
       await producer.close();
       await consumer.close();
       await client.close();
     });
 
+    test('subscriptionInitialPosition', async () => {
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        operationTimeoutSeconds: 30,
+      });
+
+      const topic = 'persistent://public/default/subscriptionInitialPosition';
+      const producer = await client.createProducer({
+        topic,
+        sendTimeoutMs: 30000,
+        batchingEnabled: false,
+      });
+      expect(producer).not.toBeNull();
+
+      const messages = [];
+      for (let i = 0; i < 2; i += 1) {
+        const msg = `my-message-${i}`;
+        producer.send({
+          data: Buffer.from(msg),
+        });
+        messages.push(msg);
+      }
+      await producer.flush();
+
+      const latestConsumer = await client.subscribe({
+        topic,
+        subscription: 'latestSub',
+        subscriptionInitialPosition: 'Latest',
+      });
+      expect(latestConsumer).not.toBeNull();
+
+      const earliestConsumer = await client.subscribe({
+        topic,
+        subscription: 'earliestSub',
+        subscriptionInitialPosition: 'Earliest',
+      });
+      expect(earliestConsumer).not.toBeNull();
+
+      for (let i = 2; i < 4; i += 1) {
+        const msg = `my-message-${i}`;
+        producer.send({
+          data: Buffer.from(msg),
+        });
+        messages.push(msg);
+      }
+      await producer.flush();
+
+      const latestResults = [];
+      const earliestResults = [];
+      for (let i = 0; i < 4; i += 1) {
+        if (i < 2) {
+          const latestMsg = await latestConsumer.receive(5000);
+          latestConsumer.acknowledge(latestMsg);
+          latestResults.push(latestMsg.getData().toString());
+        }
+
+        const earliestMsg = await earliestConsumer.receive(5000);
+        earliestConsumer.acknowledge(earliestMsg);
+        earliestResults.push(earliestMsg.getData().toString());
+      }
+      expect(lodash.difference(messages, latestResults)).toEqual(['my-message-0', 'my-message-1']);
+      expect(lodash.difference(messages, earliestResults)).toEqual([]);
+
+      await producer.close();
+      await latestConsumer.close();
+      await earliestConsumer.close();
+      await client.close();
+    });
+
     test('Produce/Read', async () => {
       const client = new Pulsar.Client({
         serviceUrl: 'pulsar://localhost:6650',