@homaiohq/napi-quickfix 0.0.0-stage → 0.2.0

package/cpp/application_bridge.h

@@ -0,0 +1,204 @@
+#ifndef NAPI_QUICKFIX_APPLICATION_BRIDGE_H
+#define NAPI_QUICKFIX_APPLICATION_BRIDGE_H
+
+#include <napi.h>
+
+#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"
+
+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,
+    // 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.
+    // 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.
+    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
+    // 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
+  // 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);
+
+  // 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;
+  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 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_;
+  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.
+  //
+  // 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;
+
+  // 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();
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_APPLICATION_BRIDGE_H

package/cpp/data_dictionary_wrap.cpp

@@ -0,0 +1,165 @@
+#include "data_dictionary_wrap.h"
+
+#include <sstream>
+#include <string>
+
+#include "errors.h"
+#include "field_map_ops.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),
+          InstanceMethod("getVersion", &DataDictionaryWrap::GetVersion),
+          InstanceMethod("getFieldName", &DataDictionaryWrap::GetFieldName),
+          InstanceMethod("getFieldTag", &DataDictionaryWrap::GetFieldTag),
+          InstanceMethod("isField", &DataDictionaryWrap::IsField),
+          InstanceMethod("isMsgType", &DataDictionaryWrap::IsMsgType),
+      });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("DataDictionaryWrap", func);
+  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) {
+  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>()});
+}
+
+// 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(), 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

@@ -0,0 +1,59 @@
+#ifndef NAPI_QUICKFIX_DATA_DICTIONARY_WRAP_H
+#define NAPI_QUICKFIX_DATA_DICTIONARY_WRAP_H
+
+#include <napi.h>
+
+#include <memory>
+
+#include "quickfix/DataDictionary.h"
+
+namespace napi_quickfix {
+
+// Napi::ObjectWrap over FIX::DataDictionary.
+//
+//   DataDictionary.fromFile(path): DataDictionary
+//   DataDictionary.fromString(xml): DataDictionary
+//   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_; }
+  // 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_;
+
+  static Napi::Value FromFile(const Napi::CallbackInfo& info);
+  static Napi::Value FromString(const Napi::CallbackInfo& info);
+
+  Napi::Value Validate(const Napi::CallbackInfo& info);
+  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
+
+#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,127 @@
+#ifndef NAPI_QUICKFIX_ENGINE_COMMON_H
+#define NAPI_QUICKFIX_ENGINE_COMMON_H
+
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+
+#include "quickfix/Exceptions.h"
+#include "quickfix/Log.h"
+#include "quickfix/Session.h"
+#include "quickfix/SessionID.h"
+#include "quickfix/SessionSettings.h"
+
+namespace napi_quickfix {
+
+// Throw ConfigError("Duplicate Session ...") if any [SESSION] of `settings`
+// that an engine of `connectionType` ("initiator" / "acceptor") would create
+// already has a live FIX::Session in this process. QuickFIX only rejects
+// duplicates within ONE settings object (SessionSettings::set); across engines
+// its Session constructor ignores addSession()'s result, so a second engine
+// would silently shadow the first in the process-wide registry that
+// lookupSession()/sendToTarget() read, and the per-engine SessionOpGate
+// registry would couple operations with the wrong engine. Call it on the JS
+// thread right before constructing the engine: engines are only created and
+// destroyed on that thread, so the check cannot race another engine.
+inline void RejectDuplicateSessions(const FIX::SessionSettings& settings,
+                                    const std::string& connectionType) {
+  for (const FIX::SessionID& id : settings.getSessions()) {
+    const FIX::Dictionary& dict = settings.get(id);
+    // Sessions of the other type are skipped by the engine (and a missing
+    // ConnectionType is its own ConfigError, raised by the engine itself).
+    if (!dict.has("ConnectionType") ||
+        dict.getString("ConnectionType") != connectionType) {
+      continue;
+    }
+    if (FIX::Session::doesSessionExist(id)) {
+      throw FIX::ConfigError("Duplicate Session " + id.toString());
+    }
+  }
+}
+
+// Delete the FIX::Session objects a FAILED engine constructor left behind.
+// FIX::Initiator/Acceptor::initialize() creates one FIX::Session per [SESSION]
+// of its connection type, registering each in the process-wide registry, and
+// if a later [SESSION] throws ConfigError the constructor unwinds WITHOUT the
+// engine destructor that would delete them: they stay registered with no
+// owner, so lookupSession() keeps resolving them and every later engine with
+// one of those ids is rejected as a duplicate for the rest of the process.
+// Call it right after the engine constructor threw, on the JS thread, with
+// the same `settings`/`connectionType` RejectDuplicateSessions() was called
+// with just before: that check guarantees every session of ours that exists
+// now was created by the failed constructor, and each one is fully
+// constructed: the only callback FIX::Session's constructor makes after
+// registering itself is onCreate, which the bridge dispatches fire-and-forget
+// (a throwing JS handler never unwinds the constructor). ~Session unregisters
+// it and destroys its store/log through the factories the wrap still owns
+// (public virtual destructor; the engine destructor does exactly this
+// `delete`).
+inline void DestroyOrphanedSessions(const FIX::SessionSettings& settings,
+                                    const std::string& connectionType) {
+  for (const FIX::SessionID& id : settings.getSessions()) {
+    const FIX::Dictionary& dict = settings.get(id);
+    if (!dict.has("ConnectionType") ||
+        dict.getString("ConnectionType") != connectionType) {
+      continue;
+    }
+    delete FIX::Session::lookupSession(id);  // nullptr-safe
+  }
+}
+
+// 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; }
+};
+
+// The wrap's LogFactory: forwards to the real one (File/Screen/Null) and
+// remembers the ENGINE-level Log that FIX::Initiator/Acceptor's constructor
+// requests with create() -- no SessionID -- before it runs initialize(). When
+// initialize() throws ConfigError the constructor unwinds without the engine
+// destructor that would hand that Log back (`m_pLogFactory->destroy(m_pLog)`),
+// and QuickFIX's own factories do not reclaim it either (~FileLogFactory does
+// not delete its m_globalLog): with log:'file' every failed construction left
+// two open streams behind. The wrap calls DestroyOrphanedEngineLog() next to
+// DestroyOrphanedSessions() when the engine constructor threw. The engine
+// keeps a raw pointer to its LogFactory for its whole life (per-session logs,
+// and the destroy() in its destructor), so this object must outlive it: it is
+// the wrap's logFactory_ member, declared before the engine.
+class TrackingLogFactory : public FIX::LogFactory {
+ public:
+  explicit TrackingLogFactory(std::unique_ptr<FIX::LogFactory> inner)
+      : inner_(std::move(inner)) {}
+
+  FIX::Log* create() override {
+    FIX::Log* log = inner_->create();  // may throw: nothing recorded then
+    engineLog_ = log;
+    return log;
+  }
+  FIX::Log* create(const FIX::SessionID& id) override {
+    return inner_->create(id);
+  }
+  void destroy(FIX::Log* log) override {
+    if (log == engineLog_) engineLog_ = nullptr;
+    inner_->destroy(log);
+  }
+
+  // Destroy the engine-level Log if the engine constructor requested one and
+  // then threw, so no engine will ever destroy() it. No-op otherwise.
+  void DestroyOrphanedEngineLog() {
+    if (engineLog_ == nullptr) return;
+    FIX::Log* log = engineLog_;
+    engineLog_ = nullptr;
+    inner_->destroy(log);
+  }
+
+ private:
+  std::unique_ptr<FIX::LogFactory> inner_;
+  FIX::Log* engineLog_ = nullptr;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_ENGINE_COMMON_H