@homaiohq/napi-quickfix 0.0.0-stage → 0.1.0

package/cpp/application_bridge.cpp

@@ -0,0 +1,382 @@
+#include "application_bridge.h"
+
+#include <mutex>
+#include <string>
+#include <utility>
+
+#include "message_wrap.h"
+#include "session_id_wrap.h"
+
+namespace napi_quickfix {
+
+namespace {
+
+// Map a CallType to the JS handler property name.
+const char* HandlerName(ApplicationBridge::CallType type) {
+  switch (type) {
+    case ApplicationBridge::CallType::kOnCreate: return "onCreate";
+    case ApplicationBridge::CallType::kOnLogon: return "onLogon";
+    case ApplicationBridge::CallType::kOnLogout: return "onLogout";
+    case ApplicationBridge::CallType::kToAdmin: return "toAdmin";
+    case ApplicationBridge::CallType::kToApp: return "toApp";
+    case ApplicationBridge::CallType::kFromAdmin: return "fromAdmin";
+    case ApplicationBridge::CallType::kFromApp: return "fromApp";
+  }
+  return "";
+}
+
+bool IsMessageBearing(ApplicationBridge::CallType type) {
+  switch (type) {
+    case ApplicationBridge::CallType::kOnCreate:
+    case ApplicationBridge::CallType::kOnLogon:
+    case ApplicationBridge::CallType::kOnLogout:
+      return false;
+    default:
+      return true;
+  }
+}
+
+// Mutating (outbound) callbacks: the JS handler may edit the message.
+bool IsMutating(ApplicationBridge::CallType type) {
+  return type == ApplicationBridge::CallType::kToAdmin ||
+         type == ApplicationBridge::CallType::kToApp;
+}
+
+}  // namespace
+
+ApplicationBridge::ApplicationBridge(Napi::Env env, Napi::Object handlers) {
+  if (!handlers.IsEmpty() && handlers.IsObject()) {
+    handlers_ = Napi::Persistent(handlers);
+  }
+
+  // Create the TSFN. No JS callback (the trampoline is the CallJs template
+  // param). Initial thread count of 1 represents the QuickFIX side; released on
+  // Release()/Abort(). Context = this. maxQueueSize 0 = unbounded.
+  tsfn_ = TSFN::New(
+      env,
+      "napi_quickfix::ApplicationBridge",  // resource name
+      0,                                    // unbounded queue
+      1,                                    // initial thread count
+      this,                                 // context
+      [](Napi::Env, void*, ApplicationBridge*) { /* finalizer: no-op */ });
+}
+
+ApplicationBridge::~ApplicationBridge() {
+  // Wake any straggling waiter so it can't block on a destroyed channel.
+  inactive_.store(true, std::memory_order_release);
+  WakeAllPending();
+  // Ensure the TSFN is released so it doesn't dangle. If already released this
+  // is a no-op-ish (Abort on an aborted tsfn returns an error we ignore).
+  if (!released_) {
+    tsfn_.Abort();
+    released_ = true;
+  }
+  if (!handlers_.IsEmpty()) {
+    handlers_.Reset();
+  }
+}
+
+void ApplicationBridge::Release() {
+  if (!released_) {
+    // Mark inactive BEFORE releasing so any QuickFIX thread that is about to
+    // dispatch sees it and bails out (pass-through) instead of racing the TSFN.
+    inactive_.store(true, std::memory_order_release);
+    WakeAllPending();
+    released_ = true;
+    tsfn_.Release();
+  }
+}
+
+void ApplicationBridge::Abort() {
+  if (!released_) {
+    inactive_.store(true, std::memory_order_release);
+    WakeAllPending();
+    released_ = true;
+    tsfn_.Abort();
+  }
+}
+
+void ApplicationBridge::Deactivate() {
+  inactive_.store(true, std::memory_order_release);
+  // Release any network thread already blocked in CallSync so the subsequent
+  // engine stop() (which joins those threads) can complete without deadlocking
+  // on the frozen main loop.
+  WakeAllPending();
+}
+
+std::uint64_t ApplicationBridge::RegisterChannel(
+    const std::shared_ptr<SyncChannel>& ch) {
+  std::lock_guard<std::mutex> lock(pendingMtx_);
+  std::uint64_t id = nextChannelId_++;
+  pending_[id] = ch;
+  return id;
+}
+
+void ApplicationBridge::UnregisterChannel(std::uint64_t id) {
+  std::lock_guard<std::mutex> lock(pendingMtx_);
+  pending_.erase(id);
+}
+
+void ApplicationBridge::WakeAllPending() {
+  std::lock_guard<std::mutex> lock(pendingMtx_);
+  for (auto& kv : pending_) {
+    auto& ch = kv.second;
+    {
+      std::lock_guard<std::mutex> chLock(ch->mtx);
+      if (!ch->done) {
+        ch->done = true;  // pass-through (default Result: no mutate, no throw)
+      }
+    }
+    ch->cv.notify_all();
+  }
+}
+
+void ApplicationBridge::Ref(Napi::Env env) {
+  if (!released_) {
+    tsfn_.Ref(env);
+  }
+}
+
+void ApplicationBridge::Unref(Napi::Env env) {
+  if (!released_) {
+    tsfn_.Unref(env);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// FIX::Application overrides (invoked on QuickFIX threads).
+// ---------------------------------------------------------------------------
+
+void ApplicationBridge::FireAndForget(CallType type, const FIX::SessionID& id) {
+  // Bridge is releasing/aborting (possibly during finalize where the TSFN is
+  // being destroyed): don't touch the TSFN. Fire-and-forget just drops.
+  if (inactive_.load(std::memory_order_acquire)) {
+    return;
+  }
+  auto* data = new CallData();
+  data->type = type;
+  data->sessionID = id;
+  data->hasMessage = false;
+  // channel stays null: fire-and-forget.
+  napi_status status = tsfn_.NonBlockingCall(data);
+  if (status != napi_ok) {
+    delete data;  // TSFN won't take ownership if the call failed.
+  }
+}
+
+ApplicationBridge::Result ApplicationBridge::CallSync(CallType type,
+                                                      const FIX::SessionID& id,
+                                                      const std::string& raw) {
+  // 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.
+  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();
+  data->type = type;
+  data->sessionID = id;
+  data->rawMessage = raw;
+  data->hasMessage = true;
+  data->channel = channel;  // shared: trampoline gets its own owning copy
+
+  napi_status status = tsfn_.BlockingCall(data);
+  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;
+    UnregisterChannel(channelId);
+    Result r;
+    return r;
+  }
+
+  // Wait for the trampoline (normal completion) or Abort/Deactivate (teardown)
+  // to signal the channel. Never blocks forever: WakeAllPending() sets done.
+  {
+    std::unique_lock<std::mutex> lock(channel->mtx);
+    channel->cv.wait(lock, [&channel] { return channel->done; });
+  }
+  UnregisterChannel(channelId);
+  std::lock_guard<std::mutex> lock(channel->mtx);
+  return channel->result;
+}
+
+void ApplicationBridge::onCreate(const FIX::SessionID& id) {
+  FireAndForget(CallType::kOnCreate, id);
+}
+
+void ApplicationBridge::onLogon(const FIX::SessionID& id) {
+  FireAndForget(CallType::kOnLogon, id);
+}
+
+void ApplicationBridge::onLogout(const FIX::SessionID& id) {
+  FireAndForget(CallType::kOnLogout, id);
+}
+
+void ApplicationBridge::toAdmin(FIX::Message& message,
+                                const FIX::SessionID& id) {
+  Result r = CallSync(CallType::kToAdmin, id, message.toString());
+  if (r.mutated) {
+    message.setString(r.editedMessage, false);
+  }
+  // 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());
+  if (r.threw) {
+    // toApp may throw DoNotSend.
+    throw FIX::DoNotSend();
+  }
+  if (r.mutated) {
+    message.setString(r.editedMessage, false);
+  }
+}
+
+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());
+  if (r.threw) {
+    if (r.errorName == "RejectLogon") throw FIX::RejectLogon(r.errorMessage);
+    if (r.errorName == "IncorrectDataFormat") throw FIX::IncorrectDataFormat(0);
+    if (r.errorName == "IncorrectTagValue") throw FIX::IncorrectTagValue(0);
+    if (r.errorName == "FieldNotFound") throw FIX::FieldNotFound(0);
+    // Default: reject the logon so the peer sees a definitive response.
+    throw FIX::RejectLogon(r.errorMessage);
+  }
+}
+
+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());
+  if (r.threw) {
+    if (r.errorName == "UnsupportedMessageType")
+      throw FIX::UnsupportedMessageType();
+    if (r.errorName == "IncorrectDataFormat") throw FIX::IncorrectDataFormat(0);
+    if (r.errorName == "IncorrectTagValue") throw FIX::IncorrectTagValue(0);
+    if (r.errorName == "FieldNotFound") throw FIX::FieldNotFound(0);
+    throw FIX::UnsupportedMessageType();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// JS-thread trampoline. Runs on the Node event-loop thread.
+// ---------------------------------------------------------------------------
+
+void ApplicationBridge::CallJs(Napi::Env env, Napi::Function /*jsCallback*/,
+                               ApplicationBridge* context, CallData* data) {
+  // RAII: always delete the CallData and, for sync calls, ALWAYS signal the
+  // channel even on early return or a thrown C++ exception in this trampoline.
+  // The signal is a no-op if Abort/Deactivate already woke the waiter (done set)
+  // — the waiter has already returned pass-through and discarded the channel.
+  struct Guard {
+    CallData* data;
+    Result result;
+    ~Guard() {
+      if (data->channel) {
+        auto& ch = *data->channel;
+        {
+          std::lock_guard<std::mutex> lock(ch.mtx);
+          if (!ch.done) {
+            ch.result = std::move(result);
+            ch.done = true;
+          }
+        }
+        ch.cv.notify_all();
+      }
+      delete data;
+    }
+  } guard{data, {}};
+
+  // env may be null during environment teardown; nothing safe to do.
+  if (env == nullptr || context == nullptr) {
+    return;
+  }
+
+  const bool isSync = (data->channel != nullptr);
+
+  Napi::HandleScope scope(env);
+
+  // Resolve the handler function, if the user provided one.
+  Napi::Function handler;
+  if (!context->handlers_.IsEmpty()) {
+    Napi::Object handlers = context->handlers_.Value();
+    Napi::Value h = handlers.Get(HandlerName(data->type));
+    if (h.IsFunction()) {
+      handler = h.As<Napi::Function>();
+    }
+  }
+
+  // Build the JS arguments: (message?, sessionID).
+  Napi::Object sessionIdObj = SessionIDWrap::NewInstance(env, data->sessionID);
+
+  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);
+    haveMsg = true;
+  }
+
+  if (handler.IsEmpty()) {
+    // No handler for this callback: pass-through (no mutation, no throw).
+    return;
+  }
+
+  try {
+    if (haveMsg) {
+      handler.Call({msgObj, sessionIdObj});
+    } else {
+      handler.Call({sessionIdObj});
+    }
+  } catch (const Napi::Error& e) {
+    if (isSync) {
+      guard.result.threw = true;
+      // Read a `.fixError` / name off the JS error to pick the FIX exception.
+      Napi::Value nameVal;
+      try {
+        nameVal = e.Value().As<Napi::Object>().Get("fixError");
+      } catch (...) {
+      }
+      if (nameVal.IsString()) {
+        guard.result.errorName = nameVal.As<Napi::String>().Utf8Value();
+      }
+      try {
+        guard.result.errorMessage = e.Message();
+      } catch (...) {
+      }
+    }
+    // For fire-and-forget, the JS error is swallowed here (there's no FIX-thread
+    // waiting). Reported best-effort by leaving it; QuickFIX doesn't care.
+  }
+
+  // For mutating sync callbacks, read back the (possibly edited) message.
+  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.mutated = true;
+    } catch (...) {
+      guard.result.mutated = false;
+    }
+  }
+  // guard destructor signals the channel (for sync) and deletes data.
+}
+
+}  // namespace napi_quickfix

package/cpp/application_bridge.h

@@ -0,0 +1,151 @@
+#ifndef NAPI_QUICKFIX_APPLICATION_BRIDGE_H
+#define NAPI_QUICKFIX_APPLICATION_BRIDGE_H
+
+#include <napi.h>
+
+#include <atomic>
+#include <condition_variable>
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include "quickfix/Application.h"
+#include "quickfix/Message.h"
+#include "quickfix/SessionID.h"
+
+namespace napi_quickfix {
+
+// Bridges QuickFIX's FIX::Application callbacks (invoked on QuickFIX's own
+// network threads) to a set of JS handler functions, via a SINGLE
+// TypedThreadSafeFunction dispatcher.
+//
+// Fire-and-forget callbacks (onCreate/onLogon/onLogout) use NonBlockingCall and
+// never wait. Synchronous mutate/throw callbacks (toAdmin/toApp/fromAdmin/
+// fromApp) use BlockingCall + a shared SyncChannel (mutex/condition_variable) so
+// the QuickFIX thread observes any message mutation or thrown FIX exception
+// before returning. Crucially, the wait can be released not only by the JS
+// trampoline but also by Deactivate()/Abort() during teardown, so a network
+// thread never blocks forever when the main event loop is frozen (e.g. inside a
+// finalize/cleanup hook). The engine wraps run start/stop/sendToTarget on libuv
+// worker threads (AsyncWorker) so the main loop stays free to service these
+// BlockingCall trampolines — this is what breaks the original deadlock.
+class ApplicationBridge : public FIX::Application {
+ public:
+  enum class CallType {
+    kOnCreate,
+    kOnLogon,
+    kOnLogout,
+    kToAdmin,
+    kToApp,
+    kFromAdmin,
+    kFromApp,
+  };
+
+  // Result returned from the JS trampoline for synchronous calls.
+  struct Result {
+    // For mutating callbacks (toAdmin/toApp), the (possibly edited) message.
+    std::string editedMessage;
+    bool mutated = false;
+    // If the JS handler threw, the FIX exception class name to re-throw
+    // (e.g. "DoNotSend", "RejectLogon", "UnsupportedMessageType") and message.
+    bool threw = false;
+    std::string errorName;
+    std::string errorMessage;
+  };
+
+  // Reply channel for a synchronous call. Heap-allocated and shared (shared_ptr)
+  // between the waiting QuickFIX thread and the JS trampoline so neither can
+  // dangle. Guarded by a mutex + condition_variable so the waiter can be woken
+  // either by the trampoline (normal completion) or by Abort()/Deactivate()
+  // (teardown), instead of blocking forever on a future when the main loop is
+  // frozen inside a cleanup hook.
+  struct SyncChannel {
+    std::mutex mtx;
+    std::condition_variable cv;
+    bool done = false;
+    Result result;
+  };
+
+  struct CallData {
+    CallType type;
+    FIX::SessionID sessionID;  // copied by value — safe across threads
+    std::string rawMessage;    // serialized message for message-bearing calls
+    bool hasMessage = false;
+    // For synchronous calls only: shared reply channel (null for fire-and-forget).
+    std::shared_ptr<SyncChannel> channel;
+  };
+
+  // The JS-thread trampoline. Runs on the Node event-loop thread. Declared
+  // before the TSFN alias because it is used as a template argument.
+  static void CallJs(Napi::Env env, Napi::Function jsCallback,
+                     ApplicationBridge* context, CallData* data);
+
+  using TSFN = Napi::TypedThreadSafeFunction<ApplicationBridge, CallData,
+                                             ApplicationBridge::CallJs>;
+
+  // Construct on the JS thread. `handlers` is the user's handlers object (may be
+  // empty/undefined). `env` is captured for control (Ref/Unref).
+  ApplicationBridge(Napi::Env env, Napi::Object handlers);
+  ~ApplicationBridge() override;
+
+  // TSFN lifecycle. Acquire is a no-op placeholder (the initial thread count is
+  // 1 from New); Release drains, Abort force-stops. Ref/Unref control whether
+  // the TSFN keeps the event loop alive.
+  void Release();
+  void Abort();
+  // Mark the bridge inactive WITHOUT touching the TSFN. Callbacks arriving on
+  // QuickFIX threads will pass through immediately. Call this on the MAIN thread
+  // BEFORE stopping the engine during finalize, so the subsequent engine stop()
+  // (which joins the network threads) can't have a callback race into a TSFN
+  // that is about to be aborted.
+  void Deactivate();
+  void Ref(Napi::Env env);
+  void Unref(Napi::Env env);
+
+  // FIX::Application overrides.
+  void onCreate(const FIX::SessionID&) override;
+  void onLogon(const FIX::SessionID&) override;
+  void onLogout(const FIX::SessionID&) override;
+  void toAdmin(FIX::Message&, const FIX::SessionID&) override;
+  void toApp(FIX::Message&, const FIX::SessionID&) EXCEPT(FIX::DoNotSend) override;
+  void fromAdmin(const FIX::Message&, const FIX::SessionID&)
+      EXCEPT(FIX::FieldNotFound, FIX::IncorrectDataFormat,
+             FIX::IncorrectTagValue, FIX::RejectLogon) override;
+  void fromApp(const FIX::Message&, const FIX::SessionID&)
+      EXCEPT(FIX::FieldNotFound, FIX::IncorrectDataFormat,
+             FIX::IncorrectTagValue, FIX::UnsupportedMessageType) override;
+
+ private:
+  void FireAndForget(CallType type, const FIX::SessionID& id);
+  // 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);
+
+  Napi::ObjectReference handlers_;
+  TSFN tsfn_;
+  bool released_ = false;
+  // Set true by Abort()/Release() (which may run on the MAIN thread during
+  // finalize) and read by the FIX::Application overrides (which run on QuickFIX
+  // network threads). Once true, the overrides must NOT touch the TSFN — during
+  // environment teardown the TSFN's internals may already be destroyed, and
+  // calling into it aborts the process. Atomic so the cross-thread read is safe.
+  std::atomic<bool> inactive_{false};
+
+  // 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.
+  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);
+  void UnregisterChannel(std::uint64_t id);
+  void WakeAllPending();
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_APPLICATION_BRIDGE_H

package/cpp/data_dictionary_wrap.cpp

@@ -0,0 +1,79 @@
+#include "data_dictionary_wrap.h"
+
+#include <sstream>
+#include <string>
+
+#include "errors.h"
+#include "message_wrap.h"
+
+namespace napi_quickfix {
+
+Napi::FunctionReference DataDictionaryWrap::constructor_;
+
+Napi::Object DataDictionaryWrap::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "DataDictionary",
+      {
+          StaticMethod("fromFile", &DataDictionaryWrap::FromFile),
+          StaticMethod("fromString", &DataDictionaryWrap::FromString),
+          InstanceMethod("validate", &DataDictionaryWrap::Validate),
+      });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("DataDictionaryWrap", func);
+  return exports;
+}
+
+// Constructor is internal: (kind: "string"|"file", payload: string).
+DataDictionaryWrap::DataDictionaryWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<DataDictionaryWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 2 || !info[0].IsString() || !info[1].IsString()) {
+    throw Napi::TypeError::New(
+        env,
+        "DataDictionary cannot be constructed directly; use "
+        "DataDictionary.fromFile() or DataDictionary.fromString()");
+  }
+  std::string kind = info[0].As<Napi::String>().Utf8Value();
+  std::string payload = info[1].As<Napi::String>().Utf8Value();
+
+  NQ_TRY(env) {
+    if (kind == "string") {
+      std::istringstream stream(payload);
+      dict_.readFromStream(stream);
+    } else {  // "file"
+      dict_.readFromURL(payload);
+    }
+  } NQ_CATCH(env)
+}
+
+Napi::Value DataDictionaryWrap::FromFile(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    throw Napi::TypeError::New(env, "fromFile(path: string)");
+  }
+  return constructor_.New(
+      {Napi::String::New(env, "file"), info[0].As<Napi::String>()});
+}
+
+Napi::Value DataDictionaryWrap::FromString(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    throw Napi::TypeError::New(env, "fromString(xml: string)");
+  }
+  return constructor_.New(
+      {Napi::String::New(env, "string"), info[0].As<Napi::String>()});
+}
+
+Napi::Value DataDictionaryWrap::Validate(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  MessageWrap* msg = MessageWrap::UnwrapArg(env, info[0], "message");
+  NQ_TRY(env) {
+    dict_.validate(msg->Message());
+  } NQ_CATCH(env)
+  return env.Undefined();
+}
+
+}  // namespace napi_quickfix

package/cpp/data_dictionary_wrap.h

@@ -0,0 +1,37 @@
+#ifndef NAPI_QUICKFIX_DATA_DICTIONARY_WRAP_H
+#define NAPI_QUICKFIX_DATA_DICTIONARY_WRAP_H
+
+#include <napi.h>
+
+#include "quickfix/DataDictionary.h"
+
+namespace napi_quickfix {
+
+// Napi::ObjectWrap over FIX::DataDictionary.
+//
+//   DataDictionary.fromFile(path): DataDictionary
+//   DataDictionary.fromString(xml): DataDictionary
+//   dd.validate(message: Message): void   (throws QuickFixError if invalid)
+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_; }
+
+ private:
+  static Napi::FunctionReference constructor_;
+
+  static Napi::Value FromFile(const Napi::CallbackInfo& info);
+  static Napi::Value FromString(const Napi::CallbackInfo& info);
+
+  Napi::Value Validate(const Napi::CallbackInfo& info);
+
+  FIX::DataDictionary dict_;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_DATA_DICTIONARY_WRAP_H

package/cpp/engine_common.cpp

@@ -0,0 +1,5 @@
+#include "engine_common.h"
+
+// This translation unit exists so engine_common.h's out-of-line vtable anchor
+// (NullLogFactory) has a home and to keep the header include-only elsewhere.
+// All methods are currently inline in the header; nothing else is needed here.

package/cpp/engine_common.h

@@ -0,0 +1,19 @@
+#ifndef NAPI_QUICKFIX_ENGINE_COMMON_H
+#define NAPI_QUICKFIX_ENGINE_COMMON_H
+
+#include "quickfix/Log.h"
+
+namespace napi_quickfix {
+
+// A LogFactory that produces no-op NullLog instances, for log:'none'. QuickFIX
+// ships NullLog but no public NullLogFactory, so we provide one.
+class NullLogFactory : public FIX::LogFactory {
+ public:
+  FIX::Log* create() override { return new FIX::NullLog(); }
+  FIX::Log* create(const FIX::SessionID&) override { return new FIX::NullLog(); }
+  void destroy(FIX::Log* log) override { delete log; }
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_ENGINE_COMMON_H