@homaiohq/napi-quickfix 0.1.0 → 0.3.0

package/cpp/application_bridge.cpp

@@ -1,10 +1,14 @@
 #include "application_bridge.h"
 
+#include <memory>
 #include <mutex>
 #include <string>
 #include <utility>
 
+#include "field_map_ops.h"
 #include "message_wrap.h"
+#include "quickfix/DataDictionaryProvider.h"
+#include "quickfix/Session.h"
 #include "session_id_wrap.h"
 
 namespace napi_quickfix {
@@ -96,6 +100,29 @@ void ApplicationBridge::Abort() {
   }
 }
 
+bool ApplicationBridge::RunAfterQueued(Napi::Env env,
+                                       std::function<void(Napi::Env)> fn) {
+  if (released_ || inactive_.load(std::memory_order_acquire)) {
+    return false;
+  }
+  auto* data = new CallData();
+  data->type = CallType::kBarrier;
+  data->hasMessage = false;
+  data->barrier = std::move(fn);
+  napi_status status = tsfn_.NonBlockingCall(data);
+  if (status != napi_ok) {
+    delete data;
+    return false;
+  }
+  // The loop must not exit before the barrier has run even if the user
+  // unref()'d the engine; after Release() the TSFN closes as soon as its queue
+  // is drained, so this only keeps the loop alive for that drain. Ref'd only
+  // once the item is queued: a refused call leaves the TSFN exactly as the
+  // caller had it (JS thread, so nothing runs in between).
+  tsfn_.Ref(env);
+  return true;
+}
+
 void ApplicationBridge::Deactivate() {
   inactive_.store(true, std::memory_order_release);
   // Release any network thread already blocked in CallSync so the subsequent
@@ -104,12 +131,21 @@ void ApplicationBridge::Deactivate() {
   WakeAllPending();
 }
 
-std::uint64_t ApplicationBridge::RegisterChannel(
-    const std::shared_ptr<SyncChannel>& ch) {
+bool ApplicationBridge::RegisterChannel(const std::shared_ptr<SyncChannel>& ch,
+                                        std::uint64_t& id) {
   std::lock_guard<std::mutex> lock(pendingMtx_);
-  std::uint64_t id = nextChannelId_++;
+  // Checked under the lock: Deactivate()/Abort()/Release() store inactive_
+  // before they take pendingMtx_ for WakeAllPending(), so either this
+  // registration lands in pending_ before the wake loop iterates it, or it
+  // observes inactive_ here and is refused. Without this re-check a caller
+  // could pass CallSync's unlocked fast-path check, register after the wake
+  // loop ran, and wait until Abort() while the JS thread is blocked on it.
+  if (inactive_.load(std::memory_order_acquire)) {
+    return false;
+  }
+  id = nextChannelId_++;
   pending_[id] = ch;
-  return id;
+  return true;
 }
 
 void ApplicationBridge::UnregisterChannel(std::uint64_t id) {
@@ -164,37 +200,58 @@ void ApplicationBridge::FireAndForget(CallType type, const FIX::SessionID& id) {
   }
 }
 
-ApplicationBridge::Result ApplicationBridge::CallSync(CallType type,
-                                                      const FIX::SessionID& id,
-                                                      const std::string& raw) {
+ApplicationBridge::Result ApplicationBridge::CallSync(
+    CallType type, const FIX::SessionID& id, const FIX::Message& message) {
   // Bridge is releasing/aborting: never call into the TSFN (its internals may be
   // torn down during finalize -> calling would abort the process). Return an
   // empty pass-through result so the QuickFIX thread proceeds without mutation
-  // or thrown exception.
+  // or thrown exception. This is only a cheap fast path; the authoritative
+  // check is the one RegisterChannel() makes under pendingMtx_.
   if (inactive_.load(std::memory_order_acquire)) {
     Result r;
     return r;
   }
 
-  auto channel = std::make_shared<SyncChannel>();
-  std::uint64_t channelId = RegisterChannel(channel);
-
-  auto* data = new CallData();
+  // Everything that can throw (the copy, its serialization, the dictionary
+  // lookup) runs before the channel is registered, and `data` is owned until
+  // the TSFN takes it: an exception (std::bad_alloc) leaks nothing and leaves
+  // no channel in pending_.
+  auto data = std::make_unique<CallData>();
   data->type = type;
   data->sessionID = id;
-  data->rawMessage = raw;
+  // Deep copy, nested entries kept typed: the engine parsed them as
+  // FIX::Group with the session dictionary, and a plain copy would slice
+  // their delimiter away.
+  fieldmap::CloneMessage(data->message, message);
+  if (type == CallType::kToAdmin || type == CallType::kToApp) {
+    // An outbound message gets BodyLength (9) and CheckSum (10) only when
+    // Session::sendRaw serializes it, after toAdmin/toApp: serialize the
+    // clone so the handler sees them too. The engine recomputes both anyway.
+    data->message.toString();
+  }
+  data->sessionDictionary = SessionDictionary(id);
   data->hasMessage = true;
+
+  auto channel = std::make_shared<SyncChannel>();
+  std::uint64_t channelId = 0;
+  if (!RegisterChannel(channel, channelId)) {
+    // Lost the race with Deactivate()/Abort(): the wake loop has already run
+    // (or is running) over pending_, so waiting now could block until Abort().
+    Result r;
+    return r;
+  }
   data->channel = channel;  // shared: trampoline gets its own owning copy
 
-  napi_status status = tsfn_.BlockingCall(data);
+  napi_status status = tsfn_.BlockingCall(data.get());
   if (status != napi_ok) {
     // TSFN is closing/aborted: it won't take ownership and won't fulfill the
-    // channel. Clean up and return a pass-through result.
-    delete data;
+    // channel. Clean up (`data` frees itself) and return a pass-through
+    // result.
     UnregisterChannel(channelId);
     Result r;
     return r;
   }
+  data.release();  // the trampoline owns it now
 
   // Wait for the trampoline (normal completion) or Abort/Deactivate (teardown)
   // to signal the channel. Never blocks forever: WakeAllPending() sets done.
@@ -207,7 +264,30 @@ ApplicationBridge::Result ApplicationBridge::CallSync(CallType type,
   return channel->result;
 }
 
+std::shared_ptr<const FIX::DataDictionary> ApplicationBridge::SessionDictionary(
+    const FIX::SessionID& id) {
+  std::lock_guard<std::mutex> lock(dictionariesMtx_);
+  auto found = dictionaries_.find(id);
+  if (found != dictionaries_.end()) {
+    return found->second;
+  }
+  FIX::Session* session = FIX::Session::lookupSession(id);
+  if (session == nullptr) {
+    return nullptr;
+  }
+  auto provider = std::make_shared<const FIX::DataDictionaryProvider>(
+      session->getDataDictionaryProvider());
+  std::shared_ptr<const FIX::DataDictionary> dictionary(
+      provider, &provider->getSessionDataDictionary(id.getBeginString()));
+  dictionaries_.emplace(id, dictionary);
+  return dictionary;
+}
+
 void ApplicationBridge::onCreate(const FIX::SessionID& id) {
+  {
+    std::lock_guard<std::mutex> lock(dictionariesMtx_);
+    dictionaries_.erase(id);
+  }
   FireAndForget(CallType::kOnCreate, id);
 }
 
@@ -221,22 +301,22 @@ void ApplicationBridge::onLogout(const FIX::SessionID& id) {
 
 void ApplicationBridge::toAdmin(FIX::Message& message,
                                 const FIX::SessionID& id) {
-  Result r = CallSync(CallType::kToAdmin, id, message.toString());
+  Result r = CallSync(CallType::kToAdmin, id, message);
   if (r.mutated) {
-    message.setString(r.editedMessage, false);
+    message = r.editedMessage;
   }
   // toAdmin doesn't throw in the FIX interface; ignore r.threw here.
 }
 
 void ApplicationBridge::toApp(FIX::Message& message, const FIX::SessionID& id)
     EXCEPT(FIX::DoNotSend) {
-  Result r = CallSync(CallType::kToApp, id, message.toString());
+  Result r = CallSync(CallType::kToApp, id, message);
   if (r.threw) {
     // toApp may throw DoNotSend.
     throw FIX::DoNotSend();
   }
   if (r.mutated) {
-    message.setString(r.editedMessage, false);
+    message = r.editedMessage;
   }
 }
 
@@ -244,7 +324,7 @@ void ApplicationBridge::fromAdmin(const FIX::Message& message,
                                   const FIX::SessionID& id)
     EXCEPT(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue,
            FIX::RejectLogon) {
-  Result r = CallSync(CallType::kFromAdmin, id, message.toString());
+  Result r = CallSync(CallType::kFromAdmin, id, message);
   if (r.threw) {
     if (r.errorName == "RejectLogon") throw FIX::RejectLogon(r.errorMessage);
     if (r.errorName == "IncorrectDataFormat") throw FIX::IncorrectDataFormat(0);
@@ -259,7 +339,7 @@ void ApplicationBridge::fromApp(const FIX::Message& message,
                                 const FIX::SessionID& id)
     EXCEPT(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue,
            FIX::UnsupportedMessageType) {
-  Result r = CallSync(CallType::kFromApp, id, message.toString());
+  Result r = CallSync(CallType::kFromApp, id, message);
   if (r.threw) {
     if (r.errorName == "UnsupportedMessageType")
       throw FIX::UnsupportedMessageType();
@@ -299,6 +379,12 @@ void ApplicationBridge::CallJs(Napi::Env env, Napi::Function /*jsCallback*/,
     }
   } guard{data, {}};
 
+  if (data->type == CallType::kBarrier) {
+    // Dropped (null env) or reached in FIFO order: either way, hand over.
+    if (data->barrier) data->barrier(env);
+    return;
+  }
+
   // env may be null during environment teardown; nothing safe to do.
   if (env == nullptr || context == nullptr) {
     return;
@@ -324,13 +410,11 @@ void ApplicationBridge::CallJs(Napi::Env env, Napi::Function /*jsCallback*/,
   Napi::Object msgObj;
   bool haveMsg = false;
   if (data->hasMessage) {
-    FIX::Message msg;
-    try {
-      msg.setString(data->rawMessage, false);
-    } catch (...) {
-      // Leave msg default-constructed if parse fails; still hand it to JS.
-    }
-    msgObj = MessageWrap::NewInstance(env, msg);
+    // Hand the structured copy over to the wrapper (data is deleted by the
+    // guard below): no string round-trip and no second copy, so the repeating
+    // groups the engine parsed stay intact for the handler.
+    msgObj = MessageWrap::NewInstance(env, std::move(data->message),
+                                      std::move(data->sessionDictionary));
     haveMsg = true;
   }
 
@@ -370,7 +454,7 @@ void ApplicationBridge::CallJs(Napi::Env env, Napi::Function /*jsCallback*/,
   if (isSync && IsMutating(data->type) && haveMsg && !guard.result.threw) {
     try {
       MessageWrap* w = Napi::ObjectWrap<MessageWrap>::Unwrap(msgObj);
-      guard.result.editedMessage = w->Message().toString();
+      guard.result.editedMessage = w->Message();
       guard.result.mutated = true;
     } catch (...) {
       guard.result.mutated = false;

package/cpp/application_bridge.h

@@ -6,12 +6,15 @@
 #include <atomic>
 #include <condition_variable>
 #include <cstdint>
+#include <functional>
+#include <map>
 #include <memory>
 #include <mutex>
 #include <string>
 #include <unordered_map>
 
 #include "quickfix/Application.h"
+#include "quickfix/DataDictionary.h"
 #include "quickfix/Message.h"
 #include "quickfix/SessionID.h"
 
@@ -41,12 +44,19 @@ class ApplicationBridge : public FIX::Application {
     kToApp,
     kFromAdmin,
     kFromApp,
+    // Not an Application callback: a closure queued by the JS thread through
+    // the same FIFO, so it runs after every event queued before it (see
+    // RunAfterQueued).
+    kBarrier,
   };
 
   // Result returned from the JS trampoline for synchronous calls.
   struct Result {
     // For mutating callbacks (toAdmin/toApp), the (possibly edited) message.
-    std::string editedMessage;
+    // Carried as a FIX::Message (not its wire string) so repeating groups the
+    // handler added survive: re-parsing a string without a dictionary would
+    // flatten them.
+    FIX::Message editedMessage;
     bool mutated = false;
     // If the JS handler threw, the FIX exception class name to re-throw
     // (e.g. "DoNotSend", "RejectLogon", "UnsupportedMessageType") and message.
@@ -71,10 +81,21 @@ class ApplicationBridge : public FIX::Application {
   struct CallData {
     CallType type;
     FIX::SessionID sessionID;  // copied by value — safe across threads
-    std::string rawMessage;    // serialized message for message-bearing calls
+    // A deep copy of the message for message-bearing calls (a
+    // fieldmap::CloneMessage, which keeps every nested group entry typed).
+    // Copied, not serialized: the engine parsed it with the session's
+    // dictionary, and only the structured copy keeps its repeating groups for
+    // the JS handler, which takes the copy over.
+    FIX::Message message;
+    // The session dictionary the JS wrapper routes the message's fields by
+    // (see SessionDictionary); null when the session is gone.
+    std::shared_ptr<const FIX::DataDictionary> sessionDictionary;
     bool hasMessage = false;
     // For synchronous calls only: shared reply channel (null for fire-and-forget).
     std::shared_ptr<SyncChannel> channel;
+    // kBarrier only. Invoked with a null Env if the item is dropped (TSFN
+    // aborted / environment teardown): then it must not touch JS.
+    std::function<void(Napi::Env)> barrier;
   };
 
   // The JS-thread trampoline. Runs on the Node event-loop thread. Declared
@@ -104,6 +125,15 @@ class ApplicationBridge : public FIX::Application {
   void Ref(Napi::Env env);
   void Unref(Napi::Env env);
 
+  // Queue `fn` to run on the JS thread AFTER every callback already queued
+  // (the TSFN queue is FIFO), and keep the event loop alive until it has run.
+  // JS thread only; call it before Release()/Abort(). Returns false, without
+  // queuing anything, if the bridge is no longer accepting work -- the caller
+  // then runs `fn` itself. `fn` receives a null Env if the queue is discarded
+  // before it is reached (Abort() / environment teardown) and must then do
+  // nothing that touches JS.
+  bool RunAfterQueued(Napi::Env env, std::function<void(Napi::Env)> fn);
+
   // FIX::Application overrides.
   void onCreate(const FIX::SessionID&) override;
   void onLogon(const FIX::SessionID&) override;
@@ -122,7 +152,20 @@ class ApplicationBridge : public FIX::Application {
   // Runs a synchronous call and returns the Result (throwing FIX exception is
   // handled by the caller-side override, which inspects Result).
   Result CallSync(CallType type, const FIX::SessionID& id,
-                  const std::string& raw);
+                  const FIX::Message& message);
+
+  // The session dictionary of `id`, shared so a JS Message can keep it past
+  // the session's lifetime: a copy of the session's DataDictionaryProvider
+  // (which shares its dictionaries' ownership) aliased to the dictionary for
+  // the session's BeginString. Built once per session, on the QuickFIX thread
+  // running the callback (the session is alive there); onCreate drops the
+  // entry so a recreated session gets its own. Null if the session is not
+  // registered.
+  std::shared_ptr<const FIX::DataDictionary> SessionDictionary(
+      const FIX::SessionID& id);
+  std::mutex dictionariesMtx_;
+  std::map<FIX::SessionID, std::shared_ptr<const FIX::DataDictionary>>
+      dictionaries_;
 
   Napi::ObjectReference handlers_;
   TSFN tsfn_;
@@ -137,11 +180,21 @@ class ApplicationBridge : public FIX::Application {
   // Wake all in-flight synchronous callers (used by Deactivate/Abort so a
   // network thread blocked in CallSync doesn't wait forever when the main loop
   // is frozen inside a cleanup hook). Registers each SyncChannel while pending.
+  //
+  // Invariant: every path that sets inactive_ stores it BEFORE taking
+  // pendingMtx_ to run WakeAllPending(), and RegisterChannel() re-checks
+  // inactive_ UNDER pendingMtx_. So a registration that saw inactive_ unset is
+  // already in pending_ when the wake loop runs, and one that lost the race is
+  // refused; either way no caller can start waiting after the wake. The JS
+  // thread relies on this when it blocks on a network thread after
+  // Deactivate() (Teardown's stop() join, DestroyEngine's gate freeze).
   std::mutex pendingMtx_;
   std::unordered_map<std::uint64_t, std::shared_ptr<SyncChannel>> pending_;
   std::uint64_t nextChannelId_ = 0;
 
-  std::uint64_t RegisterChannel(const std::shared_ptr<SyncChannel>& ch);
+  // Returns false (nothing registered) if the bridge is already inactive.
+  bool RegisterChannel(const std::shared_ptr<SyncChannel>& ch,
+                       std::uint64_t& id);
   void UnregisterChannel(std::uint64_t id);
   void WakeAllPending();
 };

package/cpp/data_dictionary_wrap.cpp

@@ -4,6 +4,7 @@
 #include <string>
 
 #include "errors.h"
+#include "field_map_ops.h"
 #include "message_wrap.h"
 
 namespace napi_quickfix {
@@ -17,6 +18,11 @@ Napi::Object DataDictionaryWrap::Init(Napi::Env env, Napi::Object exports) {
           StaticMethod("fromFile", &DataDictionaryWrap::FromFile),
           StaticMethod("fromString", &DataDictionaryWrap::FromString),
           InstanceMethod("validate", &DataDictionaryWrap::Validate),
+          InstanceMethod("getVersion", &DataDictionaryWrap::GetVersion),
+          InstanceMethod("getFieldName", &DataDictionaryWrap::GetFieldName),
+          InstanceMethod("getFieldTag", &DataDictionaryWrap::GetFieldTag),
+          InstanceMethod("isField", &DataDictionaryWrap::IsField),
+          InstanceMethod("isMsgType", &DataDictionaryWrap::IsMsgType),
       });
 
   constructor_ = Napi::Persistent(func);
@@ -26,6 +32,17 @@ Napi::Object DataDictionaryWrap::Init(Napi::Env env, Napi::Object exports) {
   return exports;
 }
 
+DataDictionaryWrap* DataDictionaryWrap::UnwrapArg(Napi::Env env,
+                                                  Napi::Value value,
+                                                  const char* argName) {
+  if (!value.IsObject() ||
+      !value.As<Napi::Object>().InstanceOf(constructor_.Value())) {
+    throw Napi::TypeError::New(
+        env, std::string(argName) + " must be a DataDictionary instance");
+  }
+  return Napi::ObjectWrap<DataDictionaryWrap>::Unwrap(value.As<Napi::Object>());
+}
+
 // Constructor is internal: (kind: "string"|"file", payload: string).
 DataDictionaryWrap::DataDictionaryWrap(const Napi::CallbackInfo& info)
     : Napi::ObjectWrap<DataDictionaryWrap>(info) {
@@ -42,9 +59,9 @@ DataDictionaryWrap::DataDictionaryWrap(const Napi::CallbackInfo& info)
   NQ_TRY(env) {
     if (kind == "string") {
       std::istringstream stream(payload);
-      dict_.readFromStream(stream);
+      dict_->readFromStream(stream);
     } else {  // "file"
-      dict_.readFromURL(payload);
+      dict_->readFromURL(payload);
     }
   } NQ_CATCH(env)
 }
@@ -67,13 +84,82 @@ Napi::Value DataDictionaryWrap::FromString(const Napi::CallbackInfo& info) {
       {Napi::String::New(env, "string"), info[0].As<Napi::String>()});
 }
 
+// validate(message, bodyOnly?: boolean). With bodyOnly the dictionary is used
+// as the application dictionary only (QuickFIX's `validate(msg, true)`): no
+// BeginString version check and no tag/value validation of the header and
+// trailer fields. The header still needs BeginString and MsgType, and every
+// field the dictionary requires, header and trailer included, must be present.
 Napi::Value DataDictionaryWrap::Validate(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   MessageWrap* msg = MessageWrap::UnwrapArg(env, info[0], "message");
+  bool bodyOnly = false;
+  if (info.Length() >= 2 && !fieldmap::IsNullish(info[1])) {
+    bodyOnly = info[1].ToBoolean().Value();
+  }
   NQ_TRY(env) {
-    dict_.validate(msg->Message());
+    dict_->validate(msg->Message(), bodyOnly);
   } NQ_CATCH(env)
   return env.Undefined();
 }
 
+// The BeginString the spec declares (e.g. "FIX.4.4"), "" if it has none.
+Napi::Value DataDictionaryWrap::GetVersion(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    return Napi::String::New(env, dict_->getVersion());
+  } NQ_CATCH(env)
+}
+
+Napi::Value DataDictionaryWrap::GetFieldName(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsNumber()) {
+    throw Napi::TypeError::New(env, "getFieldName(tag: number)");
+  }
+  int tag = fieldmap::CoerceTag(env, info[0]);
+  NQ_TRY(env) {
+    std::string name;
+    if (!dict_->getFieldName(tag, name)) {
+      return env.Undefined();
+    }
+    return Napi::String::New(env, name);
+  } NQ_CATCH(env)
+}
+
+Napi::Value DataDictionaryWrap::GetFieldTag(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    throw Napi::TypeError::New(env, "getFieldTag(name: string)");
+  }
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+  NQ_TRY(env) {
+    int tag = 0;
+    if (!dict_->getFieldTag(name, tag)) {
+      return env.Undefined();
+    }
+    return Napi::Number::New(env, tag);
+  } NQ_CATCH(env)
+}
+
+Napi::Value DataDictionaryWrap::IsField(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsNumber()) {
+    throw Napi::TypeError::New(env, "isField(tag: number)");
+  }
+  int tag = fieldmap::CoerceTag(env, info[0]);
+  NQ_TRY(env) {
+    return Napi::Boolean::New(env, dict_->isField(tag));
+  } NQ_CATCH(env)
+}
+
+Napi::Value DataDictionaryWrap::IsMsgType(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    throw Napi::TypeError::New(env, "isMsgType(msgType: string)");
+  }
+  std::string msgType = info[0].As<Napi::String>().Utf8Value();
+  NQ_TRY(env) {
+    return Napi::Boolean::New(env, dict_->isMsgType(msgType));
+  } NQ_CATCH(env)
+}
+
 }  // namespace napi_quickfix

package/cpp/data_dictionary_wrap.h

@@ -3,6 +3,8 @@
 
 #include <napi.h>
 
+#include <memory>
+
 #include "quickfix/DataDictionary.h"
 
 namespace napi_quickfix {
@@ -11,15 +13,29 @@ namespace napi_quickfix {
 //
 //   DataDictionary.fromFile(path): DataDictionary
 //   DataDictionary.fromString(xml): DataDictionary
-//   dd.validate(message: Message): void   (throws QuickFixError if invalid)
+//   dd.validate(message: Message, bodyOnly?: boolean): void
+//     (throws QuickFixError if invalid)
+//   dd.getVersion(): string
+//   dd.getFieldName(tag): string | undefined
+//   dd.getFieldTag(name): number | undefined
+//   dd.isField(tag): boolean
+//   dd.isMsgType(msgType): boolean
 class DataDictionaryWrap : public Napi::ObjectWrap<DataDictionaryWrap> {
  public:
   static Napi::Object Init(Napi::Env env, Napi::Object exports);
 
   explicit DataDictionaryWrap(const Napi::CallbackInfo& info);
 
-  FIX::DataDictionary& Dictionary() { return dict_; }
-  const FIX::DataDictionary& Dictionary() const { return dict_; }
+  FIX::DataDictionary& Dictionary() { return *dict_; }
+  const FIX::DataDictionary& Dictionary() const { return *dict_; }
+  // Shared ownership, for a Message that routes its fields by this dictionary
+  // and may outlive the JS DataDictionary.
+  std::shared_ptr<const FIX::DataDictionary> Shared() const { return dict_; }
+
+  // Unwrap a JS value that must be a DataDictionaryWrap; throws
+  // Napi::TypeError if not.
+  static DataDictionaryWrap* UnwrapArg(Napi::Env env, Napi::Value value,
+                                       const char* argName);
 
  private:
   static Napi::FunctionReference constructor_;
@@ -28,8 +44,14 @@ class DataDictionaryWrap : public Napi::ObjectWrap<DataDictionaryWrap> {
   static Napi::Value FromString(const Napi::CallbackInfo& info);
 
   Napi::Value Validate(const Napi::CallbackInfo& info);
-
-  FIX::DataDictionary dict_;
+  Napi::Value GetVersion(const Napi::CallbackInfo& info);
+  Napi::Value GetFieldName(const Napi::CallbackInfo& info);
+  Napi::Value GetFieldTag(const Napi::CallbackInfo& info);
+  Napi::Value IsField(const Napi::CallbackInfo& info);
+  Napi::Value IsMsgType(const Napi::CallbackInfo& info);
+
+  std::shared_ptr<FIX::DataDictionary> dict_ =
+      std::make_shared<FIX::DataDictionary>();
 };
 
 }  // namespace napi_quickfix