pulsar-client 1.6.2 → 1.7.0

package/src/ConsumerConfig.cc

@@ -19,6 +19,7 @@
 
 #include "ConsumerConfig.h"
 #include "Consumer.h"
+#include "SchemaInfo.h"
 #include "Message.h"
 #include <pulsar/c/consumer_configuration.h>
 #include <pulsar/c/consumer.h>
@@ -38,6 +39,7 @@ 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::string CFG_READ_COMPACTED = "readCompacted";
+static const std::string CFG_SCHEMA = "schema";
 static const std::string CFG_PRIVATE_KEY_PATH = "privateKeyPath";
 static const std::string CFG_CRYPTO_FAILURE_ACTION = "cryptoFailureAction";
 
@@ -56,18 +58,17 @@ static const std::map<std::string, pulsar_consumer_crypto_failure_action> CONSUM
     {"CONSUME", pulsar_ConsumerConsume},
 };
 
-void FinalizeListenerCallback(Napi::Env env, ListenerCallback *cb, void *) { delete cb; }
+void FinalizeListenerCallback(Napi::Env env, MessageListenerCallback *cb, void *) { delete cb; }
 
-ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
-                               std::shared_ptr<CConsumerWrapper> consumerWrapper,
-                               pulsar_message_listener messageListener)
+ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig, pulsar_message_listener messageListener)
     : topic(""),
       topicsPattern(""),
       subscription(""),
       ackTimeoutMs(0),
       nAckRedeliverTimeoutMs(60000),
       listener(nullptr) {
-  this->cConsumerConfig = pulsar_consumer_configuration_create();
+  this->cConsumerConfig = std::shared_ptr<pulsar_consumer_configuration_t>(
+      pulsar_consumer_configuration_create(), pulsar_consumer_configuration_free);
 
   if (consumerConfig.Has(CFG_TOPIC) && consumerConfig.Get(CFG_TOPIC).IsString()) {
     this->topic = consumerConfig.Get(CFG_TOPIC).ToString().Utf8Value();
@@ -93,7 +94,7 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
   if (consumerConfig.Has(CFG_SUBSCRIPTION_TYPE) && consumerConfig.Get(CFG_SUBSCRIPTION_TYPE).IsString()) {
     std::string subscriptionType = consumerConfig.Get(CFG_SUBSCRIPTION_TYPE).ToString().Utf8Value();
     if (SUBSCRIPTION_TYPE.count(subscriptionType)) {
-      pulsar_consumer_configuration_set_consumer_type(this->cConsumerConfig,
+      pulsar_consumer_configuration_set_consumer_type(this->cConsumerConfig.get(),
                                                       SUBSCRIPTION_TYPE.at(subscriptionType));
     }
   }
@@ -101,20 +102,21 @@ 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,
+      pulsar_consumer_set_subscription_initial_position(this->cConsumerConfig.get(),
                                                         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());
+    if (!consumerName.empty())
+      pulsar_consumer_set_consumer_name(this->cConsumerConfig.get(), consumerName.c_str());
   }
 
   if (consumerConfig.Has(CFG_ACK_TIMEOUT) && consumerConfig.Get(CFG_ACK_TIMEOUT).IsNumber()) {
     this->ackTimeoutMs = consumerConfig.Get(CFG_ACK_TIMEOUT).ToNumber().Int64Value();
     if (this->ackTimeoutMs == 0 || this->ackTimeoutMs >= MIN_ACK_TIMEOUT_MILLIS) {
-      pulsar_consumer_set_unacked_messages_timeout_ms(this->cConsumerConfig, this->ackTimeoutMs);
+      pulsar_consumer_set_unacked_messages_timeout_ms(this->cConsumerConfig.get(), this->ackTimeoutMs);
     }
   }
 
@@ -122,7 +124,7 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
       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,
+      pulsar_configure_set_negative_ack_redelivery_delay_ms(this->cConsumerConfig.get(),
                                                             this->nAckRedeliverTimeoutMs);
     }
   }
@@ -130,7 +132,7 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
   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) {
-      pulsar_consumer_configuration_set_receiver_queue_size(this->cConsumerConfig, receiverQueueSize);
+      pulsar_consumer_configuration_set_receiver_queue_size(this->cConsumerConfig.get(), receiverQueueSize);
     }
   }
 
@@ -139,11 +141,17 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
     int32_t receiverQueueSizeAcrossPartitions =
         consumerConfig.Get(CFG_RECV_QUEUE_ACROSS_PARTITIONS).ToNumber().Int32Value();
     if (receiverQueueSizeAcrossPartitions >= 0) {
-      pulsar_consumer_set_max_total_receiver_queue_size_across_partitions(this->cConsumerConfig,
+      pulsar_consumer_set_max_total_receiver_queue_size_across_partitions(this->cConsumerConfig.get(),
                                                                           receiverQueueSizeAcrossPartitions);
     }
   }
 
+  if (consumerConfig.Has(CFG_SCHEMA) && consumerConfig.Get(CFG_SCHEMA).IsObject()) {
+    SchemaInfo *schemaInfo = new SchemaInfo(consumerConfig.Get(CFG_SCHEMA).ToObject());
+    schemaInfo->SetConsumerSchema(this->cConsumerConfig);
+    delete schemaInfo;
+  }
+
   if (consumerConfig.Has(CFG_PROPS) && consumerConfig.Get(CFG_PROPS).IsObject()) {
     Napi::Object propObj = consumerConfig.Get(CFG_PROPS).ToObject();
     Napi::Array arr = propObj.GetPropertyNames();
@@ -151,69 +159,62 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
     for (int i = 0; i < size; i++) {
       std::string key = arr.Get(i).ToString().Utf8Value();
       std::string value = propObj.Get(key).ToString().Utf8Value();
-      pulsar_consumer_configuration_set_property(this->cConsumerConfig, key.c_str(), value.c_str());
+      pulsar_consumer_configuration_set_property(this->cConsumerConfig.get(), key.c_str(), value.c_str());
     }
   }
 
   if (consumerConfig.Has(CFG_LISTENER) && consumerConfig.Get(CFG_LISTENER).IsFunction()) {
-    this->listener = new ListenerCallback();
+    this->listener = new MessageListenerCallback();
     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,
+    pulsar_consumer_configuration_set_message_listener(this->cConsumerConfig.get(), messageListener,
                                                        this->listener);
   }
 
   if (consumerConfig.Has(CFG_READ_COMPACTED) && consumerConfig.Get(CFG_READ_COMPACTED).IsBoolean()) {
     bool readCompacted = consumerConfig.Get(CFG_READ_COMPACTED).ToBoolean();
     if (readCompacted) {
-      pulsar_consumer_set_read_compacted(this->cConsumerConfig, 1);
+      pulsar_consumer_set_read_compacted(this->cConsumerConfig.get(), 1);
     }
   }
 
   if (consumerConfig.Has(CFG_PRIVATE_KEY_PATH) && consumerConfig.Get(CFG_PRIVATE_KEY_PATH).IsString()) {
     std::string publicKeyPath = "";
     std::string privateKeyPath = consumerConfig.Get(CFG_PRIVATE_KEY_PATH).ToString().Utf8Value();
-    pulsar_consumer_configuration_set_default_crypto_key_reader(this->cConsumerConfig, publicKeyPath.c_str(),
-                                                                privateKeyPath.c_str());
+    pulsar_consumer_configuration_set_default_crypto_key_reader(
+        this->cConsumerConfig.get(), publicKeyPath.c_str(), privateKeyPath.c_str());
     if (consumerConfig.Has(CFG_CRYPTO_FAILURE_ACTION) &&
         consumerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).IsString()) {
       std::string cryptoFailureAction = consumerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).ToString().Utf8Value();
       if (CONSUMER_CRYPTO_FAILURE_ACTION.count(cryptoFailureAction)) {
         pulsar_consumer_configuration_set_crypto_failure_action(
-            this->cConsumerConfig, CONSUMER_CRYPTO_FAILURE_ACTION.at(cryptoFailureAction));
+            this->cConsumerConfig.get(), CONSUMER_CRYPTO_FAILURE_ACTION.at(cryptoFailureAction));
       }
     }
   }
 }
 
 ConsumerConfig::~ConsumerConfig() {
-  pulsar_consumer_configuration_free(this->cConsumerConfig);
-  if (this->listener) {
+  if (this->listener != nullptr) {
     this->listener->callback.Release();
   }
 }
 
-pulsar_consumer_configuration_t *ConsumerConfig::GetCConsumerConfig() { return this->cConsumerConfig; }
+std::shared_ptr<pulsar_consumer_configuration_t> ConsumerConfig::GetCConsumerConfig() {
+  return this->cConsumerConfig;
+}
 
 std::string ConsumerConfig::GetTopic() { return this->topic; }
 std::vector<std::string> ConsumerConfig::GetTopics() { return this->topics; }
 std::string ConsumerConfig::GetTopicsPattern() { return this->topicsPattern; }
 std::string ConsumerConfig::GetSubscription() { return this->subscription; }
-ListenerCallback *ConsumerConfig::GetListenerCallback() {
-  ListenerCallback *cb = this->listener;
+MessageListenerCallback *ConsumerConfig::GetListenerCallback() {
+  MessageListenerCallback *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

@@ -27,10 +27,9 @@
 
 class ConsumerConfig {
  public:
-  ConsumerConfig(const Napi::Object &consumerConfig, std::shared_ptr<CConsumerWrapper> consumerWrapper,
-                 pulsar_message_listener messageListener);
+  ConsumerConfig(const Napi::Object &consumerConfig, pulsar_message_listener messageListener);
   ~ConsumerConfig();
-  pulsar_consumer_configuration_t *GetCConsumerConfig();
+  std::shared_ptr<pulsar_consumer_configuration_t> GetCConsumerConfig();
   std::string GetTopic();
   std::vector<std::string> GetTopics();
   std::string GetTopicsPattern();
@@ -38,17 +37,17 @@ class ConsumerConfig {
   int64_t GetAckTimeoutMs();
   int64_t GetNAckRedeliverTimeoutMs();
 
-  ListenerCallback *GetListenerCallback();
+  MessageListenerCallback *GetListenerCallback();
 
  private:
-  pulsar_consumer_configuration_t *cConsumerConfig;
+  std::shared_ptr<pulsar_consumer_configuration_t> cConsumerConfig;
   std::string topic;
   std::vector<std::string> topics;
   std::string topicsPattern;
   std::string subscription;
   int64_t ackTimeoutMs;
   int64_t nAckRedeliverTimeoutMs;
-  ListenerCallback *listener;
+  MessageListenerCallback *listener;
 };
 
 #endif

package/src/Message.cc

@@ -54,7 +54,7 @@ Napi::Object Message::Init(Napi::Env env, Napi::Object exports) {
   return exports;
 }
 
-Napi::Object Message::NewInstance(Napi::Value arg, pulsar_message_t *cMessage) {
+Napi::Object Message::NewInstance(Napi::Value arg, std::shared_ptr<pulsar_message_t> cMessage) {
   Napi::Object obj = constructor.New({});
   Message *msg = Unwrap(obj);
   msg->cMessage = cMessage;
@@ -63,14 +63,14 @@ Napi::Object Message::NewInstance(Napi::Value arg, pulsar_message_t *cMessage) {
 
 Message::Message(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Message>(info), cMessage(nullptr) {}
 
-pulsar_message_t *Message::GetCMessage() { return this->cMessage; }
+std::shared_ptr<pulsar_message_t> Message::GetCMessage() { return this->cMessage; }
 
 Napi::Value Message::GetTopicName(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
   if (!ValidateCMessage(env)) {
     return env.Null();
   }
-  return Napi::String::New(env, pulsar_message_get_topic_name(this->cMessage));
+  return Napi::String::New(env, pulsar_message_get_topic_name(this->cMessage.get()));
 }
 
 Napi::Value Message::GetRedeliveryCount(const Napi::CallbackInfo &info) {
@@ -78,7 +78,7 @@ Napi::Value Message::GetRedeliveryCount(const Napi::CallbackInfo &info) {
   if (!ValidateCMessage(env)) {
     return env.Null();
   }
-  return Napi::Number::New(env, pulsar_message_get_redelivery_count(this->cMessage));
+  return Napi::Number::New(env, pulsar_message_get_redelivery_count(this->cMessage.get()));
 }
 
 Napi::Value Message::GetProperties(const Napi::CallbackInfo &info) {
@@ -87,11 +87,12 @@ Napi::Value Message::GetProperties(const Napi::CallbackInfo &info) {
     return env.Null();
   }
   Napi::Array arr = Napi::Array::New(env);
-  pulsar_string_map_t *cProperties = pulsar_message_get_properties(this->cMessage);
+  pulsar_string_map_t *cProperties = pulsar_message_get_properties(this->cMessage.get());
   int size = pulsar_string_map_size(cProperties);
   for (int i = 0; i < size; i++) {
     arr.Set(pulsar_string_map_get_key(cProperties, i), pulsar_string_map_get_value(cProperties, i));
   }
+  pulsar_string_map_free(cProperties);
   return arr;
 }
 
@@ -100,8 +101,8 @@ Napi::Value Message::GetData(const Napi::CallbackInfo &info) {
   if (!ValidateCMessage(env)) {
     return env.Null();
   }
-  void *data = const_cast<void *>(pulsar_message_get_data(this->cMessage));
-  size_t size = (size_t)pulsar_message_get_length(this->cMessage);
+  void *data = const_cast<void *>(pulsar_message_get_data(this->cMessage.get()));
+  size_t size = (size_t)pulsar_message_get_length(this->cMessage.get());
   return Napi::Buffer<char>::Copy(env, (char *)data, size);
 }
 
@@ -118,7 +119,7 @@ Napi::Value Message::GetEventTimestamp(const Napi::CallbackInfo &info) {
   if (!ValidateCMessage(env)) {
     return env.Null();
   }
-  return Napi::Number::New(env, pulsar_message_get_event_timestamp(this->cMessage));
+  return Napi::Number::New(env, pulsar_message_get_event_timestamp(this->cMessage.get()));
 }
 
 Napi::Value Message::GetPublishTimestamp(const Napi::CallbackInfo &info) {
@@ -126,7 +127,7 @@ Napi::Value Message::GetPublishTimestamp(const Napi::CallbackInfo &info) {
   if (!ValidateCMessage(env)) {
     return env.Null();
   }
-  return Napi::Number::New(env, pulsar_message_get_publish_timestamp(this->cMessage));
+  return Napi::Number::New(env, pulsar_message_get_publish_timestamp(this->cMessage.get()));
 }
 
 Napi::Value Message::GetPartitionKey(const Napi::CallbackInfo &info) {
@@ -134,11 +135,11 @@ Napi::Value Message::GetPartitionKey(const Napi::CallbackInfo &info) {
   if (!ValidateCMessage(env)) {
     return env.Null();
   }
-  return Napi::String::New(env, pulsar_message_get_partitionKey(this->cMessage));
+  return Napi::String::New(env, pulsar_message_get_partitionKey(this->cMessage.get()));
 }
 
 bool Message::ValidateCMessage(Napi::Env env) {
-  if (this->cMessage) {
+  if (this->cMessage.get()) {
     return true;
   } else {
     Napi::Error::New(env, "Message has not been built").ThrowAsJavaScriptException();
@@ -146,13 +147,13 @@ bool Message::ValidateCMessage(Napi::Env env) {
   }
 }
 
-pulsar_message_t *Message::BuildMessage(Napi::Object conf) {
-  pulsar_message_t *cMessage = pulsar_message_create();
+std::shared_ptr<pulsar_message_t> Message::BuildMessage(Napi::Object conf) {
+  std::shared_ptr<pulsar_message_t> cMessage(pulsar_message_create(), pulsar_message_free);
 
   if (conf.Has(CFG_DATA) && conf.Get(CFG_DATA).IsBuffer()) {
     Napi::Buffer<char> buf = conf.Get(CFG_DATA).As<Napi::Buffer<char>>();
     char *data = buf.Data();
-    pulsar_message_set_content(cMessage, data, buf.Length());
+    pulsar_message_set_content(cMessage.get(), data, buf.Length());
   }
 
   if (conf.Has(CFG_PROPS) && conf.Get(CFG_PROPS).IsObject()) {
@@ -162,25 +163,25 @@ pulsar_message_t *Message::BuildMessage(Napi::Object conf) {
     for (int i = 0; i < size; i++) {
       Napi::String key = arr.Get(i).ToString();
       Napi::String value = propObj.Get(key).ToString();
-      pulsar_message_set_property(cMessage, key.Utf8Value().c_str(), value.Utf8Value().c_str());
+      pulsar_message_set_property(cMessage.get(), key.Utf8Value().c_str(), value.Utf8Value().c_str());
     }
   }
 
   if (conf.Has(CFG_EVENT_TIME) && conf.Get(CFG_EVENT_TIME).IsNumber()) {
     int64_t eventTimestamp = conf.Get(CFG_EVENT_TIME).ToNumber().Int64Value();
     if (eventTimestamp >= 0) {
-      pulsar_message_set_event_timestamp(cMessage, eventTimestamp);
+      pulsar_message_set_event_timestamp(cMessage.get(), eventTimestamp);
     }
   }
 
   if (conf.Has(CFG_SEQUENCE_ID) && conf.Get(CFG_SEQUENCE_ID).IsNumber()) {
     Napi::Number sequenceId = conf.Get(CFG_SEQUENCE_ID).ToNumber();
-    pulsar_message_set_sequence_id(cMessage, sequenceId.Int64Value());
+    pulsar_message_set_sequence_id(cMessage.get(), sequenceId.Int64Value());
   }
 
   if (conf.Has(CFG_PARTITION_KEY) && conf.Get(CFG_PARTITION_KEY).IsString()) {
     Napi::String partitionKey = conf.Get(CFG_PARTITION_KEY).ToString();
-    pulsar_message_set_partition_key(cMessage, partitionKey.Utf8Value().c_str());
+    pulsar_message_set_partition_key(cMessage.get(), partitionKey.Utf8Value().c_str());
   }
 
   if (conf.Has(CFG_REPL_CLUSTERS) && conf.Get(CFG_REPL_CLUSTERS).IsArray()) {
@@ -188,44 +189,40 @@ pulsar_message_t *Message::BuildMessage(Napi::Object conf) {
     // Empty list means to disable replication
     int length = clusters.Length();
     if (length == 0) {
-      pulsar_message_disable_replication(cMessage, 1);
+      pulsar_message_disable_replication(cMessage.get(), 1);
     } else {
       char **arr = NewStringArray(length);
       for (int i = 0; i < length; i++) {
         SetString(arr, clusters.Get(i).ToString().Utf8Value().c_str(), i);
       }
-      pulsar_message_set_replication_clusters(cMessage, (const char **)arr, length);
+      pulsar_message_set_replication_clusters(cMessage.get(), (const char **)arr, length);
       FreeStringArray(arr, length);
     }
   }
 
   if (conf.Has(CFG_DELIVER_AFTER) && conf.Get(CFG_DELIVER_AFTER).IsNumber()) {
     Napi::Number deliverAfter = conf.Get(CFG_DELIVER_AFTER).ToNumber();
-    pulsar_message_set_deliver_after(cMessage, deliverAfter.Int64Value());
+    pulsar_message_set_deliver_after(cMessage.get(), deliverAfter.Int64Value());
   }
 
   if (conf.Has(CFG_DELIVER_AT) && conf.Get(CFG_DELIVER_AT).IsNumber()) {
     Napi::Number deliverAt = conf.Get(CFG_DELIVER_AT).ToNumber();
-    pulsar_message_set_deliver_at(cMessage, deliverAt.Int64Value());
+    pulsar_message_set_deliver_at(cMessage.get(), deliverAt.Int64Value());
   }
 
   if (conf.Has(CFG_DISABLE_REPLICATION) && conf.Get(CFG_DISABLE_REPLICATION).IsBoolean()) {
     Napi::Boolean disableReplication = conf.Get(CFG_DISABLE_REPLICATION).ToBoolean();
     if (disableReplication.Value()) {
-      pulsar_message_disable_replication(cMessage, 1);
+      pulsar_message_disable_replication(cMessage.get(), 1);
     }
   }
 
   if (conf.Has(CFG_ORDERING_KEY) && conf.Get(CFG_ORDERING_KEY).IsString()) {
     Napi::String orderingKey = conf.Get(CFG_ORDERING_KEY).ToString();
-    pulsar_message_set_ordering_key(cMessage, orderingKey.Utf8Value().c_str());
+    pulsar_message_set_ordering_key(cMessage.get(), orderingKey.Utf8Value().c_str());
   }
 
   return cMessage;
 }
 
-Message::~Message() {
-  if (this->cMessage != nullptr) {
-    pulsar_message_free(this->cMessage);
-  }
-}
+Message::~Message() {}

package/src/Message.h

@@ -26,16 +26,16 @@
 class Message : public Napi::ObjectWrap<Message> {
  public:
   static Napi::Object Init(Napi::Env env, Napi::Object exports);
-  static Napi::Object NewInstance(Napi::Value arg, pulsar_message_t *cMessage);
-  static pulsar_message_t *BuildMessage(Napi::Object conf);
+  static Napi::Object NewInstance(Napi::Value arg, std::shared_ptr<pulsar_message_t> cMessage);
+  static std::shared_ptr<pulsar_message_t> BuildMessage(Napi::Object conf);
   Message(const Napi::CallbackInfo &info);
   ~Message();
-  pulsar_message_t *GetCMessage();
+  std::shared_ptr<pulsar_message_t> GetCMessage();
 
  private:
   static Napi::FunctionReference constructor;
 
-  pulsar_message_t *cMessage;
+  std::shared_ptr<pulsar_message_t> cMessage;
 
   Napi::Value GetTopicName(const Napi::CallbackInfo &info);
   Napi::Value GetProperties(const Napi::CallbackInfo &info);

package/src/MessageId.cc

@@ -31,7 +31,6 @@ 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::Free, napi_static),
                                      InstanceMethod("serialize", &MessageId::Serialize),
                                      StaticMethod("deserialize", &MessageId::Deserialize, napi_static),
                                      InstanceMethod("toString", &MessageId::ToString)});
@@ -48,10 +47,13 @@ MessageId::MessageId(const Napi::CallbackInfo &info) : Napi::ObjectWrap<MessageI
   Napi::HandleScope scope(env);
 }
 
-Napi::Object MessageId::NewInstanceFromMessage(const Napi::CallbackInfo &info, pulsar_message_t *cMessage) {
+Napi::Object MessageId::NewInstanceFromMessage(const Napi::CallbackInfo &info,
+                                               std::shared_ptr<pulsar_message_t> cMessage) {
   Napi::Object obj = NewInstance(info[0]);
   MessageId *msgId = Unwrap(obj);
-  msgId->cMessageId = pulsar_message_get_message_id(cMessage);
+  std::shared_ptr<pulsar_message_id_t> cMessageId(pulsar_message_get_message_id(cMessage.get()),
+                                                  pulsar_message_id_free);
+  msgId->cMessageId = cMessageId;
   return obj;
 }
 
@@ -60,32 +62,29 @@ Napi::Object MessageId::NewInstance(Napi::Value arg) {
   return obj;
 }
 
-Napi::Object MessageId::NewInstance(pulsar_message_id_t *cMessageId) {
+Napi::Object MessageId::NewInstance(std::shared_ptr<pulsar_message_id_t> cMessageId) {
   Napi::Object obj = constructor.New({});
   MessageId *msgId = Unwrap(obj);
   msgId->cMessageId = cMessageId;
   return obj;
 }
 
-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);
-}
+void nofree(void *__ptr) {}
 
 Napi::Value MessageId::Earliest(const Napi::CallbackInfo &info) {
   Napi::Object obj = NewInstance(info[0]);
   MessageId *msgId = Unwrap(obj);
-  msgId->cMessageId = (pulsar_message_id_t *)pulsar_message_id_earliest();
-  msgId->skipCMessageIdFree = true;
+  std::shared_ptr<pulsar_message_id_t> cMessageId((pulsar_message_id_t *)pulsar_message_id_earliest(),
+                                                  nofree);
+  msgId->cMessageId = cMessageId;
   return obj;
 }
 
 Napi::Value MessageId::Latest(const Napi::CallbackInfo &info) {
   Napi::Object obj = NewInstance(info[0]);
   MessageId *msgId = Unwrap(obj);
-  msgId->cMessageId = (pulsar_message_id_t *)pulsar_message_id_latest();
-  msgId->skipCMessageIdFree = true;
+  std::shared_ptr<pulsar_message_id_t> cMessageId((pulsar_message_id_t *)pulsar_message_id_latest(), nofree);
+  msgId->cMessageId = cMessageId;
   return obj;
 }
 
@@ -95,7 +94,7 @@ Napi::Value MessageId::Serialize(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
   int len;
-  void *ptr = pulsar_message_id_serialize(GetCMessageId(), &len);
+  void *ptr = pulsar_message_id_serialize(GetCMessageId().get(), &len);
 
   return Napi::Buffer<char>::New(env, (char *)ptr, len, serializeFinalizeCallback);
 }
@@ -113,22 +112,20 @@ Napi::Value MessageId::Deserialize(const Napi::CallbackInfo &info) {
 
   Napi::Buffer<char> buf = info[0].As<Napi::Buffer<char>>();
   char *data = buf.Data();
-  msgId->cMessageId = (pulsar_message_id_t *)pulsar_message_id_deserialize(data, buf.Length());
+  std::shared_ptr<pulsar_message_id_t> cMessageId(pulsar_message_id_deserialize(data, buf.Length()),
+                                                  pulsar_message_id_free);
+  msgId->cMessageId = cMessageId;
 
   return obj;
 }
 
-pulsar_message_id_t *MessageId::GetCMessageId() { return this->cMessageId; }
+std::shared_ptr<pulsar_message_id_t> MessageId::GetCMessageId() { return this->cMessageId; }
 
 Napi::Value MessageId::ToString(const Napi::CallbackInfo &info) {
-  char *cStr = pulsar_message_id_str(this->cMessageId);
+  char *cStr = pulsar_message_id_str(this->cMessageId.get());
   std::string s(cStr);
   free(cStr);
   return Napi::String::New(info.Env(), s);
 }
 
-MessageId::~MessageId() {
-  if (!this->skipCMessageIdFree) {
-    pulsar_message_id_free(this->cMessageId);
-  }
-}
+MessageId::~MessageId() {}

package/src/MessageId.h

@@ -28,21 +28,20 @@ class MessageId : public Napi::ObjectWrap<MessageId> {
  public:
   static Napi::Object Init(Napi::Env env, Napi::Object exports);
   static Napi::Object NewInstance(Napi::Value arg);
-  static Napi::Object NewInstance(pulsar_message_id_t *cMessageId);
-  static Napi::Object NewInstanceFromMessage(const Napi::CallbackInfo &info, pulsar_message_t *cMessage);
+  static Napi::Object NewInstance(std::shared_ptr<pulsar_message_id_t> cMessageId);
+  static Napi::Object NewInstanceFromMessage(const Napi::CallbackInfo &info,
+                                             std::shared_ptr<pulsar_message_t> cMessage);
   static Napi::Value Earliest(const Napi::CallbackInfo &info);
   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 Free(const Napi::CallbackInfo &info);
   MessageId(const Napi::CallbackInfo &info);
   ~MessageId();
-  pulsar_message_id_t *GetCMessageId();
+  std::shared_ptr<pulsar_message_id_t> GetCMessageId();
 
  private:
   static Napi::FunctionReference constructor;
-  pulsar_message_id_t *cMessageId;
-  bool skipCMessageIdFree = false;
+  std::shared_ptr<pulsar_message_id_t> cMessageId;
 
   Napi::Value ToString(const Napi::CallbackInfo &info);
 };

package/src/MessageListener.h

@@ -21,19 +21,14 @@
 #define MESSAGELISTENER_H
 
 #include <napi.h>
-#include <pulsar/c/client.h>
 
-struct CConsumerWrapper {
-  pulsar_consumer_t *cConsumer;
-  CConsumerWrapper();
-  ~CConsumerWrapper();
-};
-
-struct ListenerCallback {
+struct MessageListenerCallback {
   Napi::ThreadSafeFunction callback;
 
   // Using consumer as void* since the ListenerCallback is shared between Config and Consumer.
   void *consumer;
+
+  MessageListenerCallback() : consumer(nullptr) {}
 };
 
 #endif