pulsar-client 1.6.2 → 1.8.0-rc.2

package/src/Producer.cc

@@ -21,6 +21,7 @@
 #include "ProducerConfig.h"
 #include "Message.h"
 #include "MessageId.h"
+#include "ThreadSafeDeferred.h"
 #include <pulsar/c/result.h>
 #include <memory>
 Napi::FunctionReference Producer::constructor;
@@ -40,169 +41,151 @@ void Producer::Init(Napi::Env env, Napi::Object exports) {
   constructor.SuppressDestruct();
 }
 
-void Producer::SetCProducer(pulsar_producer_t *cProducer) { this->cProducer = cProducer; }
-
-class ProducerNewInstanceWorker : public Napi::AsyncWorker {
- public:
-  ProducerNewInstanceWorker(const Napi::Promise::Deferred &deferred, pulsar_client_t *cClient,
-                            ProducerConfig *producerConfig)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cClient(cClient),
-        producerConfig(producerConfig) {}
-  ~ProducerNewInstanceWorker() {}
-  void Execute() {
-    const std::string &topic = this->producerConfig->GetTopic();
-    if (topic.empty()) {
-      SetError(std::string("Topic is required and must be specified as a string when creating producer"));
-      return;
-    }
-
-    pulsar_result result = pulsar_client_create_producer(
-        this->cClient, topic.c_str(), this->producerConfig->GetCProducerConfig(), &(this->cProducer));
-    delete this->producerConfig;
-    if (result != pulsar_result_Ok) {
-      SetError(std::string("Failed to create producer: ") + pulsar_result_str(result));
-      return;
-    }
-  }
-  void OnOK() {
-    Napi::Object obj = Producer::constructor.New({});
-    Producer *producer = Producer::Unwrap(obj);
-    producer->SetCProducer(this->cProducer);
-    this->deferred.Resolve(obj);
-  }
-  void OnError(const Napi::Error &e) { this->deferred.Reject(Napi::Error::New(Env(), e.Message()).Value()); }
+void Producer::SetCProducer(std::shared_ptr<pulsar_producer_t> cProducer) { this->cProducer = cProducer; }
 
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_client_t *cClient;
-  ProducerConfig *producerConfig;
-  pulsar_producer_t *cProducer;
+struct ProducerNewInstanceContext {
+  ProducerNewInstanceContext(std::shared_ptr<ThreadSafeDeferred> deferred,
+                             std::shared_ptr<pulsar_client_t> cClient,
+                             std::shared_ptr<ProducerConfig> producerConfig)
+      : deferred(deferred), cClient(cClient), producerConfig(producerConfig){};
+  std::shared_ptr<ThreadSafeDeferred> deferred;
+  std::shared_ptr<pulsar_client_t> cClient;
+  std::shared_ptr<ProducerConfig> producerConfig;
 };
 
-Napi::Value Producer::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>();
-  ProducerConfig *producerConfig = new ProducerConfig(config);
-  ProducerNewInstanceWorker *wk = new ProducerNewInstanceWorker(deferred, cClient, producerConfig);
-  wk->Queue();
-  return deferred.Promise();
-}
-
-Producer::Producer(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Producer>(info) {}
+Napi::Value Producer::NewInstance(const Napi::CallbackInfo &info, std::shared_ptr<pulsar_client_t> cClient) {
+  auto deferred = ThreadSafeDeferred::New(info.Env());
+  auto config = info[0].As<Napi::Object>();
+  auto producerConfig = std::make_shared<ProducerConfig>(config);
 
-class ProducerSendWorker : public Napi::AsyncWorker {
- public:
-  ProducerSendWorker(const Napi::Promise::Deferred &deferred, pulsar_producer_t *cProducer,
-                     pulsar_message_t *cMessage)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cProducer(cProducer),
-        cMessage(cMessage) {}
-  ~ProducerSendWorker() { pulsar_message_free(this->cMessage); }
-  void Execute() {
-    pulsar_result result = pulsar_producer_send(this->cProducer, this->cMessage);
-    if (result != pulsar_result_Ok) SetError(pulsar_result_str(result));
-  }
-  void OnOK() {
-    Napi::Object messageId = MessageId::NewInstance(pulsar_message_get_message_id(this->cMessage));
-    this->deferred.Resolve(messageId);
-  }
-  void OnError(const Napi::Error &e) {
-    this->deferred.Reject(
-        Napi::Error::New(Env(), std::string("Failed to send message: ") + e.Message()).Value());
+  const std::string &topic = producerConfig->GetTopic();
+  if (topic.empty()) {
+    deferred->Reject(
+        std::string("Topic is required and must be specified as a string when creating producer"));
+    return deferred->Promise();
   }
 
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_producer_t *cProducer;
-  pulsar_message_t *cMessage;
-};
+  auto ctx = new ProducerNewInstanceContext(deferred, cClient, producerConfig);
 
-Napi::Value Producer::Send(const Napi::CallbackInfo &info) {
-  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  pulsar_message_t *cMessage = Message::BuildMessage(info[0].As<Napi::Object>());
-  ProducerSendWorker *wk = new ProducerSendWorker(deferred, this->cProducer, cMessage);
-  wk->Queue();
-  return deferred.Promise();
-}
+  pulsar_client_create_producer_async(
+      cClient.get(), topic.c_str(), producerConfig->GetCProducerConfig().get(),
+      [](pulsar_result result, pulsar_producer_t *rawProducer, void *ctx) {
+        auto instanceContext = static_cast<ProducerNewInstanceContext *>(ctx);
+        auto deferred = instanceContext->deferred;
+        auto cClient = instanceContext->cClient;
+        delete instanceContext;
 
-class ProducerFlushWorker : public Napi::AsyncWorker {
- public:
-  ProducerFlushWorker(const Napi::Promise::Deferred &deferred, pulsar_producer_t *cProducer)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cProducer(cProducer) {}
+        if (result != pulsar_result_Ok) {
+          return deferred->Reject(std::string("Failed to create producer: ") + pulsar_result_str(result));
+        }
 
-  ~ProducerFlushWorker() {}
+        std::shared_ptr<pulsar_producer_t> cProducer(rawProducer, pulsar_producer_free);
 
-  void Execute() {
-    pulsar_result result = pulsar_producer_flush(this->cProducer);
-    if (result != pulsar_result_Ok) SetError(pulsar_result_str(result));
-  }
+        deferred->Resolve([cProducer](const Napi::Env env) {
+          Napi::Object obj = Producer::constructor.New({});
+          Producer *producer = Producer::Unwrap(obj);
+          producer->SetCProducer(cProducer);
+          return obj;
+        });
+      },
+      ctx);
 
-  void OnOK() { this->deferred.Resolve(Env().Null()); }
+  return deferred->Promise();
+}
 
-  void OnError(const Napi::Error &e) {
-    this->deferred.Reject(
-        Napi::Error::New(Env(), std::string("Failed to flush producer: ") + e.Message()).Value());
-  }
+Producer::Producer(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Producer>(info) {}
 
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_producer_t *cProducer;
+struct ProducerSendContext {
+  ProducerSendContext(std::shared_ptr<ThreadSafeDeferred> deferred,
+                      std::shared_ptr<pulsar_message_t> cMessage)
+      : deferred(deferred), cMessage(cMessage){};
+  std::shared_ptr<ThreadSafeDeferred> deferred;
+  std::shared_ptr<pulsar_message_t> cMessage;
 };
 
-Napi::Value Producer::Flush(const Napi::CallbackInfo &info) {
-  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  ProducerFlushWorker *wk = new ProducerFlushWorker(deferred, this->cProducer);
-  wk->Queue();
-  return deferred.Promise();
+Napi::Value Producer::Send(const Napi::CallbackInfo &info) {
+  auto cMessage = Message::BuildMessage(info[0].As<Napi::Object>());
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ProducerSendContext(deferred, cMessage);
+
+  pulsar_producer_send_async(
+      this->cProducer.get(), cMessage.get(),
+      [](pulsar_result result, pulsar_message_id_t *msgId, void *ctx) {
+        auto producerSendContext = static_cast<ProducerSendContext *>(ctx);
+        auto deferred = producerSendContext->deferred;
+        auto cMessage = producerSendContext->cMessage;
+        delete producerSendContext;
+
+        std::shared_ptr<pulsar_message_id_t> cMessageId(msgId, pulsar_message_id_free);
+
+        if (result != pulsar_result_Ok) {
+          deferred->Reject(std::string("Failed to send message: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve([cMessageId](const Napi::Env env) { return MessageId::NewInstance(cMessageId); });
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }
 
-class ProducerCloseWorker : public Napi::AsyncWorker {
- public:
-  ProducerCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_producer_t *cProducer)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cProducer(cProducer) {}
-  ~ProducerCloseWorker() {}
-  void Execute() {
-    pulsar_result result = pulsar_producer_close(this->cProducer);
-    if (result != pulsar_result_Ok) SetError(pulsar_result_str(result));
-  }
-  void OnOK() { this->deferred.Resolve(Env().Null()); }
-  void OnError(const Napi::Error &e) {
-    this->deferred.Reject(
-        Napi::Error::New(Env(), std::string("Failed to close producer: ") + e.Message()).Value());
-  }
-
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_producer_t *cProducer;
-};
+Napi::Value Producer::Flush(const Napi::CallbackInfo &info) {
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_producer_flush_async(
+      this->cProducer.get(),
+      [](pulsar_result result, void *ctx) {
+        auto deferredContext = static_cast<ExtDeferredContext *>(ctx);
+        auto deferred = deferredContext->deferred;
+        delete deferredContext;
+
+        if (result != pulsar_result_Ok) {
+          deferred->Reject(std::string("Failed to flush producer: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
+}
 
 Napi::Value Producer::Close(const Napi::CallbackInfo &info) {
-  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  ProducerCloseWorker *wk = new ProducerCloseWorker(deferred, this->cProducer);
-  wk->Queue();
-  return deferred.Promise();
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_producer_close_async(
+      this->cProducer.get(),
+      [](pulsar_result result, void *ctx) {
+        auto deferredContext = static_cast<ExtDeferredContext *>(ctx);
+        auto deferred = deferredContext->deferred;
+        delete deferredContext;
+
+        if (result != pulsar_result_Ok) {
+          deferred->Reject(std::string("Failed to close producer: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }
 
 Napi::Value Producer::GetProducerName(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
-  return Napi::String::New(env, pulsar_producer_get_producer_name(this->cProducer));
+  return Napi::String::New(env, pulsar_producer_get_producer_name(this->cProducer.get()));
 }
 
 Napi::Value Producer::GetTopic(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
-  return Napi::String::New(env, pulsar_producer_get_topic(this->cProducer));
+  return Napi::String::New(env, pulsar_producer_get_topic(this->cProducer.get()));
 }
 
 Napi::Value Producer::IsConnected(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
-  return Napi::Boolean::New(env, pulsar_producer_is_connected(this->cProducer));
+  return Napi::Boolean::New(env, pulsar_producer_is_connected(this->cProducer.get()));
 }
 
-Producer::~Producer() { pulsar_producer_free(this->cProducer); }
+Producer::~Producer() {}

package/src/Producer.h

@@ -27,14 +27,14 @@
 class Producer : public Napi::ObjectWrap<Producer> {
  public:
   static void Init(Napi::Env env, Napi::Object exports);
-  static Napi::Value NewInstance(const Napi::CallbackInfo &info, pulsar_client_t *cClient);
+  static Napi::Value NewInstance(const Napi::CallbackInfo &info, std::shared_ptr<pulsar_client_t> cClient);
   static Napi::FunctionReference constructor;
   Producer(const Napi::CallbackInfo &info);
   ~Producer();
-  void SetCProducer(pulsar_producer_t *cProducer);
+  void SetCProducer(std::shared_ptr<pulsar_producer_t> cProducer);
 
  private:
-  pulsar_producer_t *cProducer;
+  std::shared_ptr<pulsar_producer_t> cProducer;
   Napi::Value Send(const Napi::CallbackInfo &info);
   Napi::Value Flush(const Napi::CallbackInfo &info);
   Napi::Value Close(const Napi::CallbackInfo &info);

package/src/ProducerConfig.cc

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-
+#include "SchemaInfo.h"
 #include "ProducerConfig.h"
 #include <map>
 
@@ -33,10 +33,12 @@ static const std::string CFG_COMPRESS_TYPE = "compressionType";
 static const std::string CFG_BATCH_ENABLED = "batchingEnabled";
 static const std::string CFG_BATCH_MAX_DELAY = "batchingMaxPublishDelayMs";
 static const std::string CFG_BATCH_MAX_MSG = "batchingMaxMessages";
+static const std::string CFG_SCHEMA = "schema";
 static const std::string CFG_PROPS = "properties";
 static const std::string CFG_PUBLIC_KEY_PATH = "publicKeyPath";
 static const std::string CFG_ENCRYPTION_KEY = "encryptionKey";
 static const std::string CFG_CRYPTO_FAILURE_ACTION = "cryptoFailureAction";
+static const std::string CFG_CHUNK_ENABLED = "chunkingEnabled";
 
 static const std::map<std::string, pulsar_partitions_routing_mode> MESSAGE_ROUTING_MODE = {
     {"UseSinglePartition", pulsar_UseSinglePartition},
@@ -62,7 +64,8 @@ static std::map<std::string, pulsar_producer_crypto_failure_action> PRODUCER_CRY
 };
 
 ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
-  this->cProducerConfig = pulsar_producer_configuration_create();
+  this->cProducerConfig = std::shared_ptr<pulsar_producer_configuration_t>(
+      pulsar_producer_configuration_create(), pulsar_producer_configuration_free);
 
   if (producerConfig.Has(CFG_TOPIC) && producerConfig.Get(CFG_TOPIC).IsString()) {
     this->topic = producerConfig.Get(CFG_TOPIC).ToString().Utf8Value();
@@ -71,25 +74,25 @@ ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
   if (producerConfig.Has(CFG_PRODUCER_NAME) && producerConfig.Get(CFG_PRODUCER_NAME).IsString()) {
     std::string producerName = producerConfig.Get(CFG_PRODUCER_NAME).ToString().Utf8Value();
     if (!producerName.empty())
-      pulsar_producer_configuration_set_producer_name(this->cProducerConfig, producerName.c_str());
+      pulsar_producer_configuration_set_producer_name(this->cProducerConfig.get(), producerName.c_str());
   }
 
   if (producerConfig.Has(CFG_SEND_TIMEOUT) && producerConfig.Get(CFG_SEND_TIMEOUT).IsNumber()) {
     int32_t sendTimeoutMs = producerConfig.Get(CFG_SEND_TIMEOUT).ToNumber().Int32Value();
     if (sendTimeoutMs > 0) {
-      pulsar_producer_configuration_set_send_timeout(this->cProducerConfig, sendTimeoutMs);
+      pulsar_producer_configuration_set_send_timeout(this->cProducerConfig.get(), sendTimeoutMs);
     }
   }
 
   if (producerConfig.Has(CFG_INIT_SEQUENCE_ID) && producerConfig.Get(CFG_INIT_SEQUENCE_ID).IsNumber()) {
     int64_t initialSequenceId = producerConfig.Get(CFG_INIT_SEQUENCE_ID).ToNumber().Int64Value();
-    pulsar_producer_configuration_set_initial_sequence_id(this->cProducerConfig, initialSequenceId);
+    pulsar_producer_configuration_set_initial_sequence_id(this->cProducerConfig.get(), initialSequenceId);
   }
 
   if (producerConfig.Has(CFG_MAX_PENDING) && producerConfig.Get(CFG_MAX_PENDING).IsNumber()) {
     int32_t maxPendingMessages = producerConfig.Get(CFG_MAX_PENDING).ToNumber().Int32Value();
     if (maxPendingMessages > 0) {
-      pulsar_producer_configuration_set_max_pending_messages(this->cProducerConfig, maxPendingMessages);
+      pulsar_producer_configuration_set_max_pending_messages(this->cProducerConfig.get(), maxPendingMessages);
     }
   }
 
@@ -98,47 +101,47 @@ ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
     int32_t maxPendingMessagesAcrossPartitions =
         producerConfig.Get(CFG_MAX_PENDING_ACROSS_PARTITIONS).ToNumber().Int32Value();
     if (maxPendingMessagesAcrossPartitions > 0) {
-      pulsar_producer_configuration_set_max_pending_messages(this->cProducerConfig,
-                                                             maxPendingMessagesAcrossPartitions);
+      pulsar_producer_configuration_set_max_pending_messages_across_partitions(
+          this->cProducerConfig.get(), maxPendingMessagesAcrossPartitions);
     }
   }
 
   if (producerConfig.Has(CFG_BLOCK_IF_QUEUE_FULL) &&
       producerConfig.Get(CFG_BLOCK_IF_QUEUE_FULL).IsBoolean()) {
     bool blockIfQueueFull = producerConfig.Get(CFG_BLOCK_IF_QUEUE_FULL).ToBoolean().Value();
-    pulsar_producer_configuration_set_block_if_queue_full(this->cProducerConfig, blockIfQueueFull);
+    pulsar_producer_configuration_set_block_if_queue_full(this->cProducerConfig.get(), blockIfQueueFull);
   }
 
   if (producerConfig.Has(CFG_ROUTING_MODE) && producerConfig.Get(CFG_ROUTING_MODE).IsString()) {
     std::string messageRoutingMode = producerConfig.Get(CFG_ROUTING_MODE).ToString().Utf8Value();
     if (MESSAGE_ROUTING_MODE.count(messageRoutingMode))
-      pulsar_producer_configuration_set_partitions_routing_mode(this->cProducerConfig,
+      pulsar_producer_configuration_set_partitions_routing_mode(this->cProducerConfig.get(),
                                                                 MESSAGE_ROUTING_MODE.at(messageRoutingMode));
   }
 
   if (producerConfig.Has(CFG_HASH_SCHEME) && producerConfig.Get(CFG_HASH_SCHEME).IsString()) {
     std::string hashingScheme = producerConfig.Get(CFG_HASH_SCHEME).ToString().Utf8Value();
     if (HASHING_SCHEME.count(hashingScheme))
-      pulsar_producer_configuration_set_hashing_scheme(this->cProducerConfig,
+      pulsar_producer_configuration_set_hashing_scheme(this->cProducerConfig.get(),
                                                        HASHING_SCHEME.at(hashingScheme));
   }
 
   if (producerConfig.Has(CFG_COMPRESS_TYPE) && producerConfig.Get(CFG_COMPRESS_TYPE).IsString()) {
     std::string compressionType = producerConfig.Get(CFG_COMPRESS_TYPE).ToString().Utf8Value();
     if (COMPRESSION_TYPE.count(compressionType))
-      pulsar_producer_configuration_set_compression_type(this->cProducerConfig,
+      pulsar_producer_configuration_set_compression_type(this->cProducerConfig.get(),
                                                          COMPRESSION_TYPE.at(compressionType));
   }
 
   if (producerConfig.Has(CFG_BATCH_ENABLED) && producerConfig.Get(CFG_BATCH_ENABLED).IsBoolean()) {
     bool batchingEnabled = producerConfig.Get(CFG_BATCH_ENABLED).ToBoolean().Value();
-    pulsar_producer_configuration_set_batching_enabled(this->cProducerConfig, batchingEnabled);
+    pulsar_producer_configuration_set_batching_enabled(this->cProducerConfig.get(), batchingEnabled);
   }
 
   if (producerConfig.Has(CFG_BATCH_MAX_DELAY) && producerConfig.Get(CFG_BATCH_MAX_DELAY).IsNumber()) {
     int64_t batchingMaxPublishDelayMs = producerConfig.Get(CFG_BATCH_MAX_DELAY).ToNumber().Int64Value();
     if (batchingMaxPublishDelayMs > 0) {
-      pulsar_producer_configuration_set_batching_max_publish_delay_ms(this->cProducerConfig,
+      pulsar_producer_configuration_set_batching_max_publish_delay_ms(this->cProducerConfig.get(),
                                                                       (long)batchingMaxPublishDelayMs);
     }
   }
@@ -146,10 +149,17 @@ ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
   if (producerConfig.Has(CFG_BATCH_MAX_MSG) && producerConfig.Get(CFG_BATCH_MAX_MSG).IsNumber()) {
     uint32_t batchingMaxMessages = producerConfig.Get(CFG_BATCH_MAX_MSG).ToNumber().Uint32Value();
     if (batchingMaxMessages > 0) {
-      pulsar_producer_configuration_set_batching_max_messages(this->cProducerConfig, batchingMaxMessages);
+      pulsar_producer_configuration_set_batching_max_messages(this->cProducerConfig.get(),
+                                                              batchingMaxMessages);
     }
   }
 
+  if (producerConfig.Has(CFG_SCHEMA) && producerConfig.Get(CFG_SCHEMA).IsObject()) {
+    SchemaInfo* schemaInfo = new SchemaInfo(producerConfig.Get(CFG_SCHEMA).ToObject());
+    schemaInfo->SetProducerSchema(this->cProducerConfig);
+    delete schemaInfo;
+  }
+
   if (producerConfig.Has(CFG_PROPS) && producerConfig.Get(CFG_PROPS).IsObject()) {
     Napi::Object propObj = producerConfig.Get(CFG_PROPS).ToObject();
     Napi::Array arr = propObj.GetPropertyNames();
@@ -157,7 +167,7 @@ ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
     for (int i = 0; i < size; i++) {
       Napi::String key = arr.Get(i).ToString();
       Napi::String value = propObj.Get(key).ToString();
-      pulsar_producer_configuration_set_property(this->cProducerConfig, key.Utf8Value().c_str(),
+      pulsar_producer_configuration_set_property(this->cProducerConfig.get(), key.Utf8Value().c_str(),
                                                  value.Utf8Value().c_str());
     }
   }
@@ -165,24 +175,31 @@ ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
   if (producerConfig.Has(CFG_PUBLIC_KEY_PATH) && producerConfig.Get(CFG_PUBLIC_KEY_PATH).IsString()) {
     std::string publicKeyPath = producerConfig.Get(CFG_PUBLIC_KEY_PATH).ToString().Utf8Value();
     std::string privateKeyPath = "";
-    pulsar_producer_configuration_set_default_crypto_key_reader(this->cProducerConfig, publicKeyPath.c_str(),
-                                                                privateKeyPath.c_str());
+    pulsar_producer_configuration_set_default_crypto_key_reader(
+        this->cProducerConfig.get(), publicKeyPath.c_str(), privateKeyPath.c_str());
     if (producerConfig.Has(CFG_ENCRYPTION_KEY) && producerConfig.Get(CFG_ENCRYPTION_KEY).IsString()) {
       std::string encryptionKey = producerConfig.Get(CFG_ENCRYPTION_KEY).ToString().Utf8Value();
-      pulsar_producer_configuration_set_encryption_key(this->cProducerConfig, encryptionKey.c_str());
+      pulsar_producer_configuration_set_encryption_key(this->cProducerConfig.get(), encryptionKey.c_str());
     }
     if (producerConfig.Has(CFG_CRYPTO_FAILURE_ACTION) &&
         producerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).IsString()) {
       std::string cryptoFailureAction = producerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).ToString().Utf8Value();
       if (PRODUCER_CRYPTO_FAILURE_ACTION.count(cryptoFailureAction))
         pulsar_producer_configuration_set_crypto_failure_action(
-            this->cProducerConfig, PRODUCER_CRYPTO_FAILURE_ACTION.at(cryptoFailureAction));
+            this->cProducerConfig.get(), PRODUCER_CRYPTO_FAILURE_ACTION.at(cryptoFailureAction));
     }
   }
+
+  if (producerConfig.Has(CFG_CHUNK_ENABLED) && producerConfig.Get(CFG_CHUNK_ENABLED).IsBoolean()) {
+    bool chunkingEnabled = producerConfig.Get(CFG_CHUNK_ENABLED).ToBoolean().Value();
+    pulsar_producer_configuration_set_chunking_enabled(this->cProducerConfig.get(), chunkingEnabled);
+  }
 }
 
-ProducerConfig::~ProducerConfig() { pulsar_producer_configuration_free(this->cProducerConfig); }
+ProducerConfig::~ProducerConfig() {}
 
-pulsar_producer_configuration_t* ProducerConfig::GetCProducerConfig() { return this->cProducerConfig; }
+std::shared_ptr<pulsar_producer_configuration_t> ProducerConfig::GetCProducerConfig() {
+  return this->cProducerConfig;
+}
 
 std::string ProducerConfig::GetTopic() { return this->topic; }

package/src/ProducerConfig.h

@@ -27,11 +27,11 @@ class ProducerConfig {
  public:
   ProducerConfig(const Napi::Object &producerConfig);
   ~ProducerConfig();
-  pulsar_producer_configuration_t *GetCProducerConfig();
+  std::shared_ptr<pulsar_producer_configuration_t> GetCProducerConfig();
   std::string GetTopic();
 
  private:
-  pulsar_producer_configuration_t *cProducerConfig;
+  std::shared_ptr<pulsar_producer_configuration_t> cProducerConfig;
   std::string topic;
 };