@homaiohq/napi-quickfix 0.3.0 → 0.3.1

package/cpp/acceptor_wrap.cpp

@@ -185,6 +185,14 @@ void AcceptorWrap::DestroyStoppedEngine() {
   SessionOpGate::Unregister(sessionIDs_, gate_.get());
   acceptor_.reset();
   gate_->Unfreeze();
+  // The engine is gone, so nothing will call the handlers again: drop the
+  // bridge's reference to them. It is what kept this wrap reachable from the
+  // user's Engine object (the handlers close over it) and so made the wrap
+  // -- and the Engine, its listeners and the parsed dictionaries -- immortal.
+  // On the graceful path this runs from the barrier queued behind every
+  // callback stop() fired, so none of them is lost; on the force path the
+  // TSFN was aborted first, discarding the queue.
+  if (bridge_) bridge_->DropHandlers();
 }
 
 Napi::Value AcceptorWrap::Start(const Napi::CallbackInfo& info) {
@@ -248,9 +256,13 @@ Napi::Value AcceptorWrap::Stop(const Napi::CallbackInfo& info) {
     return deferred.Promise();
   }
   if (!acceptor_) {
-    // Already torn down: just release the TSFN and resolve.
+    // Already torn down: just release the TSFN, drop the handlers (nothing
+    // can call them without an engine) and resolve.
     stopped_ = true;
-    if (bridge_) bridge_->Release();
+    if (bridge_) {
+      bridge_->Release();
+      bridge_->DropHandlers();
+    }
     deferred.Resolve(env.Undefined());
     return deferred.Promise();
   }
@@ -323,8 +335,15 @@ Napi::Value AcceptorWrap::Stop(const Napi::CallbackInfo& info) {
           self->gate_->Unfreeze();
           if (bridge) {
             if (force) {
+              // The abort discarded the queue: no callback can reach JS
+              // any more, so the handlers can go now.
               bridge->Abort();
+              bridge->DropHandlers();
             } else {
+              // Callbacks already queued (a trailing 'logout') are still
+              // dispatched after the release, and read the handlers: keep
+              // them. The retried stop() drops them in
+              // DestroyStoppedEngine().
               bridge->Release();
             }
           }

package/cpp/addon.cpp

@@ -30,7 +30,7 @@ void RegisterSessionStatic(Napi::Env env, Napi::Object exports);
 namespace {
 
 // Keep in sync with package.json "version".
-constexpr const char* kAddonVersion = "0.3.0";
+constexpr const char* kAddonVersion = "0.3.1";
 
 Napi::Value Version(const Napi::CallbackInfo& info) {
   return Napi::String::New(info.Env(), kAddonVersion);

package/cpp/application_bridge.cpp

@@ -167,6 +167,18 @@ void ApplicationBridge::WakeAllPending() {
   }
 }
 
+void ApplicationBridge::DropHandlers() {
+  if (!handlers_.IsEmpty()) {
+    handlers_.Reset();
+  }
+  // The dictionaries pin a parsed FIX spec per session (a copy of the
+  // session's DataDictionaryProvider, which shares the dictionary's
+  // ownership); the sessions that could still want them are gone. Locked
+  // for form: the network threads that fill the map are joined by now.
+  std::lock_guard<std::mutex> lock(dictionariesMtx_);
+  dictionaries_.clear();
+}
+
 void ApplicationBridge::Ref(Napi::Env env) {
   if (!released_) {
     tsfn_.Ref(env);

package/cpp/application_bridge.h

@@ -125,6 +125,13 @@ class ApplicationBridge : public FIX::Application {
   void Ref(Napi::Env env);
   void Unref(Napi::Env env);
 
+  // Drop what the bridge roots on the engine's behalf: the handlers object
+  // and the per-session dictionaries (see handlers_ below). JS thread only;
+  // call it once the engine is gone, or once no queued callback can reach JS
+  // any more (after Abort()). A callback dispatched afterwards passes
+  // through as if no handler were installed.
+  void DropHandlers();
+
   // 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
@@ -167,6 +174,14 @@ class ApplicationBridge : public FIX::Application {
   std::map<FIX::SessionID, std::shared_ptr<const FIX::DataDictionary>>
       dictionaries_;
 
+  // The user's handlers object, held strongly for the engine's whole life so
+  // a started engine stays reachable through them (the wrapper's handlers
+  // close over the Engine), like a net.Server does through its listeners.
+  // That makes a reference cycle through native memory the GC cannot see:
+  // wrap -> bridge -> handlers -> Engine -> wrap. The wraps break it with
+  // DropHandlers() as soon as the engine is destroyed (stop() settled, or
+  // the force/failed-stop paths that abort the TSFN); the destructor's Reset
+  // is only the fallback for a wrap collected without stop().
   Napi::ObjectReference handlers_;
   TSFN tsfn_;
   bool released_ = false;

package/cpp/initiator_wrap.cpp

@@ -207,6 +207,14 @@ void InitiatorWrap::DestroyStoppedEngine() {
   SessionOpGate::Unregister(sessionIDs_, gate_.get());
   initiator_.reset();
   gate_->Unfreeze();
+  // The engine is gone, so nothing will call the handlers again: drop the
+  // bridge's reference to them. It is what kept this wrap reachable from the
+  // user's Engine object (the handlers close over it) and so made the wrap
+  // -- and the Engine, its listeners and the parsed dictionaries -- immortal.
+  // On the graceful path this runs from the barrier queued behind every
+  // callback stop() fired, so none of them is lost; on the force path the
+  // TSFN was aborted first, discarding the queue.
+  if (bridge_) bridge_->DropHandlers();
 }
 
 Napi::Value InitiatorWrap::Start(const Napi::CallbackInfo& info) {
@@ -272,9 +280,13 @@ Napi::Value InitiatorWrap::Stop(const Napi::CallbackInfo& info) {
     return deferred.Promise();
   }
   if (!initiator_) {
-    // Already torn down: just release the TSFN and resolve.
+    // Already torn down: just release the TSFN, drop the handlers (nothing
+    // can call them without an engine) and resolve.
     stopped_ = true;
-    if (bridge_) bridge_->Release();
+    if (bridge_) {
+      bridge_->Release();
+      bridge_->DropHandlers();
+    }
     deferred.Resolve(env.Undefined());
     return deferred.Promise();
   }
@@ -347,8 +359,15 @@ Napi::Value InitiatorWrap::Stop(const Napi::CallbackInfo& info) {
           self->gate_->Unfreeze();
           if (bridge) {
             if (force) {
+              // The abort discarded the queue: no callback can reach JS
+              // any more, so the handlers can go now.
               bridge->Abort();
+              bridge->DropHandlers();
             } else {
+              // Callbacks already queued (a trailing 'logout') are still
+              // dispatched after the release, and read the handlers: keep
+              // them. The retried stop() drops them in
+              // DestroyStoppedEngine().
               bridge->Release();
             }
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homaiohq/napi-quickfix",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Modern Node-API (N-API) C++ binding for the QuickFIX FIX-protocol engine.",
   "license": "MIT",
   "repository": {