pulsar-client 1.6.2 → 1.8.0-rc1

package/src/Reader.cc

@@ -20,6 +20,8 @@
 #include "Message.h"
 #include "Reader.h"
 #include "ReaderConfig.h"
+#include "MessageId.h"
+#include "ThreadSafeDeferred.h"
 #include <pulsar/c/result.h>
 #include <pulsar/c/reader.h>
 #include <atomic>
@@ -35,6 +37,8 @@ void Reader::Init(Napi::Env env, Napi::Object exports) {
                                         InstanceMethod("readNext", &Reader::ReadNext),
                                         InstanceMethod("hasNext", &Reader::HasNext),
                                         InstanceMethod("isConnected", &Reader::IsConnected),
+                                        InstanceMethod("seek", &Reader::Seek),
+                                        InstanceMethod("seekTimestamp", &Reader::SeekTimestamp),
                                         InstanceMethod("close", &Reader::Close),
                                     });
 
@@ -43,10 +47,11 @@ void Reader::Init(Napi::Env env, Napi::Object exports) {
 }
 
 struct ReaderListenerProxyData {
-  pulsar_message_t *cMessage;
+  std::shared_ptr<pulsar_message_t> cMessage;
   Reader *reader;
 
-  ReaderListenerProxyData(pulsar_message_t *cMessage, Reader *reader) : cMessage(cMessage), reader(reader) {}
+  ReaderListenerProxyData(std::shared_ptr<pulsar_message_t> cMessage, Reader *reader)
+      : cMessage(cMessage), reader(reader) {}
 };
 
 void ReaderListenerProxy(Napi::Env env, Napi::Function jsCallback, ReaderListenerProxyData *data) {
@@ -57,7 +62,8 @@ void ReaderListenerProxy(Napi::Env env, Napi::Function jsCallback, ReaderListene
   jsCallback.Call({msg, reader->Value()});
 }
 
-void ReaderListener(pulsar_reader_t *cReader, pulsar_message_t *cMessage, void *ctx) {
+void ReaderListener(pulsar_reader_t *rawReader, pulsar_message_t *rawMessage, void *ctx) {
+  std::shared_ptr<pulsar_message_t> cMessage(rawMessage, pulsar_message_free);
   ReaderListenerCallback *readerListenerCallback = (ReaderListenerCallback *)ctx;
   Reader *reader = (Reader *)readerListenerCallback->reader;
   if (readerListenerCallback->callback.Acquire() != napi_ok) {
@@ -68,101 +74,85 @@ void ReaderListener(pulsar_reader_t *cReader, pulsar_message_t *cMessage, void *
   readerListenerCallback->callback.Release();
 }
 
-void Reader::SetCReader(std::shared_ptr<CReaderWrapper> cReader) { this->wrapper = cReader; }
+void Reader::SetCReader(std::shared_ptr<pulsar_reader_t> cReader) { this->cReader = cReader; }
 void Reader::SetListenerCallback(ReaderListenerCallback *listener) {
-  if (listener) {
-    // Maintain reference to reader, so it won't get garbage collected
-    // since, when we have a listener, we don't have to maintain reference to reader (in js code)
-    this->Ref();
+  if (this->listener != nullptr) {
+    // It is only safe to set the listener once for the lifecycle of the Reader
+    return;
+  }
 
-    // Pass reader as argument
+  if (listener != nullptr) {
     listener->reader = this;
+    // If a reader listener is set, the Reader instance is kept alive even if it goes out of scope in JS code.
+    this->Ref();
+    this->listener = listener;
   }
-
-  this->listener = listener;
 }
 
 Reader::Reader(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Reader>(info), listener(nullptr) {}
 
-class ReaderNewInstanceWorker : public Napi::AsyncWorker {
- public:
-  ReaderNewInstanceWorker(const Napi::Promise::Deferred &deferred, pulsar_client_t *cClient,
-                          ReaderConfig *readerConfig, std::shared_ptr<CReaderWrapper> readerWrapper)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cClient(cClient),
-        readerConfig(readerConfig),
-        readerWrapper(readerWrapper),
-        done(false) {}
-  ~ReaderNewInstanceWorker() {}
-  void Execute() {
-    const std::string &topic = this->readerConfig->GetTopic();
-    if (topic.empty()) {
-      std::string msg("Topic is required and must be specified as a string when creating reader");
-      SetError(msg);
-      return;
-    }
-    if (this->readerConfig->GetCStartMessageId() == nullptr) {
-      std::string msg(
-          "StartMessageId is required and must be specified as a MessageId object when creating reader");
-      SetError(msg);
-      return;
-    }
-
-    pulsar_client_create_reader_async(this->cClient, topic.c_str(), this->readerConfig->GetCStartMessageId(),
-                                      this->readerConfig->GetCReaderConfig(),
-                                      &ReaderNewInstanceWorker::createReaderCallback, (void *)this);
-
-    while (!done) {
-      std::this_thread::yield();
-    }
-  }
-  void OnOK() {
-    Napi::Object obj = Reader::constructor.New({});
-    Reader *reader = Reader::Unwrap(obj);
-    reader->SetCReader(this->readerWrapper);
-    reader->SetListenerCallback(this->listener);
-    this->deferred.Resolve(obj);
-  }
-  void OnError(const Napi::Error &e) { this->deferred.Reject(Napi::Error::New(Env(), e.Message()).Value()); }
+struct ReaderNewInstanceContext {
+  ReaderNewInstanceContext(std::shared_ptr<ThreadSafeDeferred> deferred,
+                           std::shared_ptr<pulsar_client_t> cClient,
+                           std::shared_ptr<ReaderConfig> readerConfig)
+      : deferred(deferred), cClient(cClient), readerConfig(readerConfig){};
+  std::shared_ptr<ThreadSafeDeferred> deferred;
+  std::shared_ptr<pulsar_client_t> cClient;
+  std::shared_ptr<ReaderConfig> readerConfig;
+
+  static void createReaderCallback(pulsar_result result, pulsar_reader_t *rawReader, void *ctx) {
+    auto instanceContext = static_cast<ReaderNewInstanceContext *>(ctx);
+    auto deferred = instanceContext->deferred;
+    auto cClient = instanceContext->cClient;
+    auto readerConfig = instanceContext->readerConfig;
+    delete instanceContext;
 
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_client_t *cClient;
-  pulsar_reader_t *cReader;
-  ReaderConfig *readerConfig;
-  ReaderListenerCallback *listener;
-  std::shared_ptr<CReaderWrapper> readerWrapper;
-  std::atomic<bool> done;
-  static void createReaderCallback(pulsar_result result, pulsar_reader_t *reader, void *ctx) {
-    ReaderNewInstanceWorker *worker = (ReaderNewInstanceWorker *)ctx;
     if (result != pulsar_result_Ok) {
-      worker->SetError(std::string("Failed to create reader: ") + pulsar_result_str(result));
-    } else {
-      worker->readerWrapper->cReader = reader;
-      worker->listener = worker->readerConfig->GetListenerCallback();
+      return deferred->Reject(std::string("Failed to create reader: ") + pulsar_result_str(result));
     }
 
-    delete worker->readerConfig;
-    worker->done = true;
+    auto cReader = std::shared_ptr<pulsar_reader_t>(rawReader, pulsar_reader_free);
+
+    deferred->Resolve([cReader, readerConfig](const Napi::Env env) {
+      Napi::Object obj = Reader::constructor.New({});
+      Reader *reader = Reader::Unwrap(obj);
+      reader->SetCReader(cReader);
+      reader->SetListenerCallback(readerConfig->GetListenerCallback());
+      return obj;
+    });
   }
 };
 
-Napi::Value Reader::NewInstance(const Napi::CallbackInfo &info, pulsar_client_t *cClient) {
-  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
+Napi::Value Reader::NewInstance(const Napi::CallbackInfo &info, std::shared_ptr<pulsar_client_t> cClient) {
+  auto deferred = ThreadSafeDeferred::New(info.Env());
   Napi::Object config = info[0].As<Napi::Object>();
 
-  std::shared_ptr<CReaderWrapper> readerWrapper = std::make_shared<CReaderWrapper>();
+  auto readerConfig = std::make_shared<ReaderConfig>(config, &ReaderListener);
 
-  ReaderConfig *readerConfig = new ReaderConfig(config, readerWrapper, &ReaderListener);
-  ReaderNewInstanceWorker *wk = new ReaderNewInstanceWorker(deferred, cClient, readerConfig, readerWrapper);
-  wk->Queue();
-  return deferred.Promise();
+  const std::string &topic = readerConfig->GetTopic();
+  if (topic.empty()) {
+    deferred->Reject(std::string("Topic is required and must be specified as a string when creating reader"));
+    return deferred->Promise();
+  }
+  if (readerConfig->GetCStartMessageId().get() == nullptr) {
+    deferred->Reject(std::string(
+        "StartMessageId is required and must be specified as a MessageId object when creating reader"));
+    return deferred->Promise();
+  }
+
+  auto ctx = new ReaderNewInstanceContext(deferred, cClient, readerConfig);
+
+  pulsar_client_create_reader_async(cClient.get(), topic.c_str(), readerConfig->GetCStartMessageId().get(),
+                                    readerConfig->GetCReaderConfig().get(),
+                                    &ReaderNewInstanceContext::createReaderCallback, ctx);
+
+  return deferred->Promise();
 }
 
+// We still need a read worker because the c api is missing the equivalent async definition
 class ReaderReadNextWorker : public Napi::AsyncWorker {
  public:
-  ReaderReadNextWorker(const Napi::Promise::Deferred &deferred, pulsar_reader_t *cReader,
+  ReaderReadNextWorker(const Napi::Promise::Deferred &deferred, std::shared_ptr<pulsar_reader_t> cReader,
                        int64_t timeout = -1)
       : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
         deferred(deferred),
@@ -171,14 +161,16 @@ class ReaderReadNextWorker : public Napi::AsyncWorker {
   ~ReaderReadNextWorker() {}
   void Execute() {
     pulsar_result result;
+    pulsar_message_t *rawMessage;
     if (timeout > 0) {
-      result = pulsar_reader_read_next_with_timeout(this->cReader, &(this->cMessage), timeout);
+      result = pulsar_reader_read_next_with_timeout(this->cReader.get(), &rawMessage, timeout);
     } else {
-      result = pulsar_reader_read_next(this->cReader, &(this->cMessage));
+      result = pulsar_reader_read_next(this->cReader.get(), &rawMessage);
     }
     if (result != pulsar_result_Ok) {
-      SetError(std::string("Failed to received message ") + pulsar_result_str(result));
+      SetError(std::string("Failed to receive message: ") + pulsar_result_str(result));
     }
+    this->cMessage = std::shared_ptr<pulsar_message_t>(rawMessage, pulsar_message_free);
   }
   void OnOK() {
     Napi::Object obj = Message::NewInstance({}, this->cMessage);
@@ -188,20 +180,19 @@ class ReaderReadNextWorker : public Napi::AsyncWorker {
 
  private:
   Napi::Promise::Deferred deferred;
-  pulsar_reader_t *cReader;
-  pulsar_message_t *cMessage;
+  std::shared_ptr<pulsar_reader_t> cReader;
+  std::shared_ptr<pulsar_message_t> cMessage;
   int64_t timeout;
 };
 
 Napi::Value Reader::ReadNext(const Napi::CallbackInfo &info) {
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
   if (info[0].IsUndefined()) {
-    ReaderReadNextWorker *wk = new ReaderReadNextWorker(deferred, this->wrapper->cReader);
+    ReaderReadNextWorker *wk = new ReaderReadNextWorker(deferred, this->cReader);
     wk->Queue();
   } else {
     Napi::Number timeout = info[0].As<Napi::Object>().ToNumber();
-    ReaderReadNextWorker *wk =
-        new ReaderReadNextWorker(deferred, this->wrapper->cReader, timeout.Int64Value());
+    ReaderReadNextWorker *wk = new ReaderReadNextWorker(deferred, this->cReader, timeout.Int64Value());
     wk->Queue();
   }
   return deferred.Promise();
@@ -209,7 +200,7 @@ Napi::Value Reader::ReadNext(const Napi::CallbackInfo &info) {
 
 Napi::Value Reader::HasNext(const Napi::CallbackInfo &info) {
   int value = 0;
-  pulsar_result result = pulsar_reader_has_message_available(this->wrapper->cReader, &value);
+  pulsar_result result = pulsar_reader_has_message_available(this->cReader.get(), &value);
   if (result != pulsar_result_Ok) {
     Napi::Error::New(info.Env(), "Failed to check if next message is available").ThrowAsJavaScriptException();
     return Napi::Boolean::New(info.Env(), false);
@@ -222,57 +213,85 @@ Napi::Value Reader::HasNext(const Napi::CallbackInfo &info) {
 
 Napi::Value Reader::IsConnected(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
-  return Napi::Boolean::New(env, pulsar_reader_is_connected(this->wrapper->cReader));
+  return Napi::Boolean::New(env, pulsar_reader_is_connected(this->cReader.get()));
 }
 
-class ReaderCloseWorker : public Napi::AsyncWorker {
- public:
-  ReaderCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_reader_t *cReader, Reader *reader)
-      : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
-        deferred(deferred),
-        cReader(cReader),
-        reader(reader) {}
-  ~ReaderCloseWorker() {}
-  void Execute() {
-    pulsar_result result = pulsar_reader_close(this->cReader);
-    if (result != pulsar_result_Ok) SetError(pulsar_result_str(result));
-  }
-  void OnOK() {
-    this->reader->Cleanup();
-    this->deferred.Resolve(Env().Null());
-  }
-  void OnError(const Napi::Error &e) {
-    this->deferred.Reject(
-        Napi::Error::New(Env(), std::string("Failed to close reader: ") + e.Message()).Value());
-  }
+Napi::Value Reader::Seek(const Napi::CallbackInfo &info) {
+  auto obj = info[0].As<Napi::Object>();
+  auto *msgId = MessageId::Unwrap(obj);
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_reader_seek_async(
+      this->cReader.get(), msgId->GetCMessageId().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 seek message by id: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
+}
 
- private:
-  Napi::Promise::Deferred deferred;
-  pulsar_reader_t *cReader;
-  Reader *reader;
-};
+Napi::Value Reader::SeekTimestamp(const Napi::CallbackInfo &info) {
+  Napi::Number timestamp = info[0].As<Napi::Object>().ToNumber();
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+
+  pulsar_reader_seek_by_timestamp_async(
+      this->cReader.get(), timestamp.Int64Value(),
+      [](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 seek message by timestamp: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
+}
 
 Napi::Value Reader::Close(const Napi::CallbackInfo &info) {
-  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  ReaderCloseWorker *wk = new ReaderCloseWorker(deferred, this->wrapper->cReader, this);
-  wk->Queue();
-  return deferred.Promise();
+  auto deferred = ThreadSafeDeferred::New(Env());
+  auto ctx = new ExtDeferredContext(deferred);
+  this->Cleanup();
+
+  pulsar_reader_close_async(
+      this->cReader.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 reader: ") + pulsar_result_str(result));
+        } else {
+          deferred->Resolve(THREADSAFE_DEFERRED_RESOLVER(env.Null()));
+        }
+      },
+      ctx);
+
+  return deferred->Promise();
 }
 
 void Reader::Cleanup() {
-  if (this->listener) {
-    this->CleanupListener();
+  if (this->listener != nullptr) {
+    this->listener->callback.Release();
+    this->Unref();
+    this->listener = nullptr;
   }
 }
 
-void Reader::CleanupListener() {
-  this->Unref();
-  this->listener->callback.Release();
-  this->listener = nullptr;
-}
-
-Reader::~Reader() {
-  if (this->listener) {
-    this->CleanupListener();
-  }
-}
+Reader::~Reader() { this->Cleanup(); }

package/src/Reader.h

@@ -27,21 +27,23 @@
 class Reader : public Napi::ObjectWrap<Reader> {
  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;
   Reader(const Napi::CallbackInfo &info);
   ~Reader();
-  void SetCReader(std::shared_ptr<CReaderWrapper> cReader);
+  void SetCReader(std::shared_ptr<pulsar_reader_t> cReader);
   void SetListenerCallback(ReaderListenerCallback *listener);
   void Cleanup();
 
  private:
-  std::shared_ptr<CReaderWrapper> wrapper;
+  std::shared_ptr<pulsar_reader_t> cReader;
   ReaderListenerCallback *listener;
 
   Napi::Value ReadNext(const Napi::CallbackInfo &info);
   Napi::Value HasNext(const Napi::CallbackInfo &info);
   Napi::Value IsConnected(const Napi::CallbackInfo &info);
+  Napi::Value Seek(const Napi::CallbackInfo &info);
+  Napi::Value SeekTimestamp(const Napi::CallbackInfo &info);
   Napi::Value Close(const Napi::CallbackInfo &info);
   void CleanupListener();
 };

package/src/ReaderConfig.cc

@@ -31,10 +31,10 @@ static const std::string CFG_LISTENER = "listener";
 
 void FinalizeListenerCallback(Napi::Env env, ReaderListenerCallback *cb, void *) { delete cb; }
 
-ReaderConfig::ReaderConfig(const Napi::Object &readerConfig, std::shared_ptr<CReaderWrapper> readerWrapper,
-                           pulsar_reader_listener readerListener)
+ReaderConfig::ReaderConfig(const Napi::Object &readerConfig, pulsar_reader_listener readerListener)
     : topic(""), cStartMessageId(NULL), listener(nullptr) {
-  this->cReaderConfig = pulsar_reader_configuration_create();
+  this->cReaderConfig = std::shared_ptr<pulsar_reader_configuration_t>(pulsar_reader_configuration_create(),
+                                                                       pulsar_reader_configuration_free);
 
   if (readerConfig.Has(CFG_TOPIC) && readerConfig.Get(CFG_TOPIC).IsString()) {
     this->topic = readerConfig.Get(CFG_TOPIC).ToString().Utf8Value();
@@ -48,14 +48,14 @@ ReaderConfig::ReaderConfig(const Napi::Object &readerConfig, std::shared_ptr<CRe
   if (readerConfig.Has(CFG_RECV_QUEUE) && readerConfig.Get(CFG_RECV_QUEUE).IsNumber()) {
     int32_t receiverQueueSize = readerConfig.Get(CFG_RECV_QUEUE).ToNumber().Int32Value();
     if (receiverQueueSize >= 0) {
-      pulsar_reader_configuration_set_receiver_queue_size(this->cReaderConfig, receiverQueueSize);
+      pulsar_reader_configuration_set_receiver_queue_size(this->cReaderConfig.get(), receiverQueueSize);
     }
   }
 
   if (readerConfig.Has(CFG_READER_NAME) && readerConfig.Get(CFG_READER_NAME).IsString()) {
     std::string readerName = readerConfig.Get(CFG_READER_NAME).ToString().Utf8Value();
     if (!readerName.empty())
-      pulsar_reader_configuration_set_reader_name(this->cReaderConfig, readerName.c_str());
+      pulsar_reader_configuration_set_reader_name(this->cReaderConfig.get(), readerName.c_str());
   }
 
   if (readerConfig.Has(CFG_SUBSCRIPTION_ROLE_PREFIX) &&
@@ -63,13 +63,13 @@ ReaderConfig::ReaderConfig(const Napi::Object &readerConfig, std::shared_ptr<CRe
     std::string subscriptionRolePrefix =
         readerConfig.Get(CFG_SUBSCRIPTION_ROLE_PREFIX).ToString().Utf8Value();
     if (!subscriptionRolePrefix.empty())
-      pulsar_reader_configuration_set_reader_name(this->cReaderConfig, subscriptionRolePrefix.c_str());
+      pulsar_reader_configuration_set_reader_name(this->cReaderConfig.get(), subscriptionRolePrefix.c_str());
   }
 
   if (readerConfig.Has(CFG_READ_COMPACTED) && readerConfig.Get(CFG_READ_COMPACTED).IsBoolean()) {
     bool readCompacted = readerConfig.Get(CFG_READ_COMPACTED).ToBoolean();
     if (readCompacted) {
-      pulsar_reader_configuration_set_read_compacted(this->cReaderConfig, 1);
+      pulsar_reader_configuration_set_read_compacted(this->cReaderConfig.get(), 1);
     }
   }
 
@@ -79,33 +79,27 @@ ReaderConfig::ReaderConfig(const Napi::Object &readerConfig, std::shared_ptr<CRe
         readerConfig.Env(), readerConfig.Get(CFG_LISTENER).As<Napi::Function>(), "Reader Listener Callback",
         1, 1, (void *)NULL, FinalizeListenerCallback, listener);
     this->listener->callback = std::move(callback);
-    pulsar_reader_configuration_set_reader_listener(this->cReaderConfig, readerListener, this->listener);
+    pulsar_reader_configuration_set_reader_listener(this->cReaderConfig.get(), readerListener,
+                                                    this->listener);
   }
 }
 
 ReaderConfig::~ReaderConfig() {
-  pulsar_reader_configuration_free(this->cReaderConfig);
-  if (this->listener) {
+  if (this->listener != nullptr) {
     this->listener->callback.Release();
   }
 }
 
-pulsar_reader_configuration_t *ReaderConfig::GetCReaderConfig() { return this->cReaderConfig; }
+std::shared_ptr<pulsar_reader_configuration_t> ReaderConfig::GetCReaderConfig() {
+  return this->cReaderConfig;
+}
 
 std::string ReaderConfig::GetTopic() { return this->topic; }
 
-pulsar_message_id_t *ReaderConfig::GetCStartMessageId() { return this->cStartMessageId; }
+std::shared_ptr<pulsar_message_id_t> ReaderConfig::GetCStartMessageId() { return this->cStartMessageId; }
 
 ReaderListenerCallback *ReaderConfig::GetListenerCallback() {
   ReaderListenerCallback *cb = this->listener;
   this->listener = nullptr;
   return cb;
 }
-
-CReaderWrapper::CReaderWrapper() : cReader(nullptr) {}
-
-CReaderWrapper::~CReaderWrapper() {
-  if (this->cReader) {
-    pulsar_reader_free(this->cReader);
-  }
-}

package/src/ReaderConfig.h

@@ -28,18 +28,17 @@
 
 class ReaderConfig {
  public:
-  ReaderConfig(const Napi::Object &readerConfig, std::shared_ptr<CReaderWrapper> readerWrapper,
-               pulsar_reader_listener readerListener);
+  ReaderConfig(const Napi::Object &readerConfig, pulsar_reader_listener readerListener);
   ~ReaderConfig();
-  pulsar_reader_configuration_t *GetCReaderConfig();
-  pulsar_message_id_t *GetCStartMessageId();
+  std::shared_ptr<pulsar_reader_configuration_t> GetCReaderConfig();
+  std::shared_ptr<pulsar_message_id_t> GetCStartMessageId();
   std::string GetTopic();
   ReaderListenerCallback *GetListenerCallback();
 
  private:
   std::string topic;
-  pulsar_message_id_t *cStartMessageId;
-  pulsar_reader_configuration_t *cReaderConfig;
+  std::shared_ptr<pulsar_message_id_t> cStartMessageId;
+  std::shared_ptr<pulsar_reader_configuration_t> cReaderConfig;
   ReaderListenerCallback *listener;
 };
 

package/src/ReaderListener.h

@@ -21,19 +21,14 @@
 #define READER_LISTENER_H
 
 #include <napi.h>
-#include <pulsar/c/client.h>
-
-struct CReaderWrapper {
-  pulsar_reader_t *cReader;
-  CReaderWrapper();
-  ~CReaderWrapper();
-};
 
 struct ReaderListenerCallback {
   Napi::ThreadSafeFunction callback;
 
   // Using reader as void* since the ReaderListenerCallback is shared between Config and Reader.
   void *reader;
+
+  ReaderListenerCallback() : reader(nullptr) {}
 };
 
 #endif

package/src/SchemaInfo.cc

@@ -0,0 +1,78 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+#include "SchemaInfo.h"
+#include <map>
+
+static const std::string CFG_SCHEMA_TYPE = "schemaType";
+static const std::string CFG_NAME = "name";
+static const std::string CFG_SCHEMA = "schema";
+static const std::string CFG_PROPS = "properties";
+
+static const std::map<std::string, pulsar_schema_type> SCHEMA_TYPE = {{"None", pulsar_None},
+                                                                      {"String", pulsar_String},
+                                                                      {"Json", pulsar_Json},
+                                                                      {"Protobuf", pulsar_Protobuf},
+                                                                      {"Avro", pulsar_Avro},
+                                                                      {"Boolean", pulsar_Boolean},
+                                                                      {"Int8", pulsar_Int8},
+                                                                      {"Int16", pulsar_Int16},
+                                                                      {"Int32", pulsar_Int32},
+                                                                      {"Int64", pulsar_Int64},
+                                                                      {"Float32", pulsar_Float32},
+                                                                      {"Float64", pulsar_Float64},
+                                                                      {"KeyValue", pulsar_KeyValue},
+                                                                      {"Bytes", pulsar_Bytes},
+                                                                      {"AutoConsume", pulsar_AutoConsume},
+                                                                      {"AutoPublish", pulsar_AutoPublish}};
+
+SchemaInfo::SchemaInfo(const Napi::Object &schemaInfo) : cSchemaType(pulsar_Bytes), name("BYTES"), schema() {
+  this->cProperties = pulsar_string_map_create();
+  if (schemaInfo.Has(CFG_SCHEMA_TYPE) && schemaInfo.Get(CFG_SCHEMA_TYPE).IsString()) {
+    this->name = schemaInfo.Get(CFG_SCHEMA_TYPE).ToString().Utf8Value();
+    this->cSchemaType = SCHEMA_TYPE.at(schemaInfo.Get(CFG_SCHEMA_TYPE).ToString().Utf8Value());
+  }
+  if (schemaInfo.Has(CFG_NAME) && schemaInfo.Get(CFG_NAME).IsString()) {
+    this->name = schemaInfo.Get(CFG_NAME).ToString().Utf8Value();
+  }
+  if (schemaInfo.Has(CFG_SCHEMA) && schemaInfo.Get(CFG_SCHEMA).IsString()) {
+    this->schema = schemaInfo.Get(CFG_SCHEMA).ToString().Utf8Value();
+  }
+  if (schemaInfo.Has(CFG_PROPS) && schemaInfo.Get(CFG_PROPS).IsObject()) {
+    Napi::Object propObj = schemaInfo.Get(CFG_PROPS).ToObject();
+    Napi::Array arr = propObj.GetPropertyNames();
+    int size = arr.Length();
+    for (int i = 0; i < size; i++) {
+      Napi::String key = arr.Get(i).ToString();
+      Napi::String value = propObj.Get(key).ToString();
+      pulsar_string_map_put(this->cProperties, key.Utf8Value().c_str(), value.Utf8Value().c_str());
+    }
+  }
+}
+
+void SchemaInfo::SetProducerSchema(std::shared_ptr<pulsar_producer_configuration_t> cProducerConfiguration) {
+  pulsar_producer_configuration_set_schema_info(cProducerConfiguration.get(), this->cSchemaType,
+                                                this->name.c_str(), this->schema.c_str(), this->cProperties);
+}
+
+void SchemaInfo::SetConsumerSchema(std::shared_ptr<pulsar_consumer_configuration_t> cConsumerConfiguration) {
+  pulsar_consumer_configuration_set_schema_info(cConsumerConfiguration.get(), this->cSchemaType,
+                                                this->name.c_str(), this->schema.c_str(), this->cProperties);
+}
+
+SchemaInfo::~SchemaInfo() { pulsar_string_map_free(this->cProperties); }

package/src/SchemaInfo.h

@@ -0,0 +1,41 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef SCHEMA_INFO_H
+#define SCHEMA_INFO_H
+
+#include <napi.h>
+#include <pulsar/c/producer_configuration.h>
+#include <pulsar/c/consumer_configuration.h>
+
+class SchemaInfo {
+ public:
+  SchemaInfo(const Napi::Object &schemaInfo);
+  ~SchemaInfo();
+  void SetProducerSchema(std::shared_ptr<pulsar_producer_configuration_t> cProducerConfiguration);
+  void SetConsumerSchema(std::shared_ptr<pulsar_consumer_configuration_t> cConsumerConfiguration);
+
+ private:
+  pulsar_schema_type cSchemaType;
+  std::string name;
+  std::string schema;
+  pulsar_string_map_t *cProperties;
+};
+
+#endif