@homaiohq/napi-quickfix 0.0.0-stage → 0.2.0

package/cpp/engine_workers.h

@@ -0,0 +1,167 @@
+#ifndef NAPI_QUICKFIX_ENGINE_WORKERS_H
+#define NAPI_QUICKFIX_ENGINE_WORKERS_H
+
+#include <napi.h>
+
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <utility>
+
+#include "errors.h"
+
+namespace napi_quickfix {
+
+// One-shot completion signal from a libuv worker to the JS thread. The stop
+// worker signals it once its operation (FIX stop() + gate freeze) has
+// returned, success or not; the wrap's Teardown() waits on it rather than
+// destroying the engine under an operation that may still be running it.
+class StopCompletion {
+ public:
+  void Signal() {
+    {
+      std::lock_guard<std::mutex> lock(mtx_);
+      done_ = true;
+    }
+    cv_.notify_all();
+  }
+  void Wait() {
+    std::unique_lock<std::mutex> lock(mtx_);
+    cv_.wait(lock, [this] { return done_; });
+  }
+
+ private:
+  std::mutex mtx_;
+  std::condition_variable cv_;
+  bool done_ = false;
+};
+
+// A generic AsyncWorker that runs a blocking QuickFIX engine operation
+// (start/stop) on a libuv worker thread and resolves/rejects a JS Promise.
+// (The per-message SendToTargetWorker lives in session_static.cpp.)
+//
+// Why off-thread: start()/stop() synchronously invoke FIX::Application callbacks
+// (toAdmin/toApp during send-on-logon, onLogout during stop) which the
+// ApplicationBridge dispatches back to the JS thread via a TSFN BlockingCall +
+// future. If the operation ran ON the JS thread, the event loop couldn't service
+// the TSFN trampoline and we'd deadlock. Running it on a worker thread keeps the
+// main event loop free to run CallJs.
+//
+// Lifetime: the worker holds a Napi::ObjectReference to the owning wrap object so
+// it (and its bridge / engine / factories) can't be GC'd while the op is in
+// flight. The reference is released when the promise is settled -- through
+// the Settlement handed to onSettled, which the wrap may settle later than
+// OnOK (on the JS thread) when the promise has to wait for deferred work,
+// e.g. an engine destruction queued behind the bridge's pending callbacks.
+class EngineOpWorker : public Napi::AsyncWorker {
+ public:
+  // The promise plus the owner reference, moved out of the worker (which
+  // deletes itself once OnOK/OnError returns) so settling can outlive it.
+  class Settlement {
+   public:
+    Settlement(Napi::Promise::Deferred deferred, Napi::ObjectReference ownerRef,
+               CapturedError err)
+        : deferred_(std::move(deferred)),
+          ownerRef_(std::move(ownerRef)),
+          err_(std::move(err)) {}
+
+    // Resolve, or reject with the error the op threw, and release the owner
+    // reference. JS thread only; idempotent.
+    void Settle() {
+      if (done_) return;
+      done_ = true;
+      Napi::Env env = deferred_.Env();
+      Napi::HandleScope scope(env);
+      if (err_.has) {
+        deferred_.Reject(err_.ToError(env).Value());
+      } else {
+        deferred_.Resolve(env.Undefined());
+      }
+      ownerRef_.Reset();
+    }
+
+    // The environment is going away before the promise could be settled:
+    // leave the promise pending and the reference to the environment's own
+    // cleanup, touching nothing that may already be torn down.
+    void Abandon() {
+      if (done_) return;
+      done_ = true;
+      ownerRef_.SuppressDestruct();
+    }
+
+   private:
+    Napi::Promise::Deferred deferred_;
+    Napi::ObjectReference ownerRef_;
+    CapturedError err_;
+    bool done_ = false;
+  };
+
+  // onSettled(ok, settlement) runs on the JS thread once op() has returned
+  // (ok) or thrown (!ok). It must eventually Settle() (or Abandon()) the
+  // settlement -- right away, or later on the JS thread.
+  using OnSettled =
+      std::function<void(bool, const std::shared_ptr<Settlement>&)>;
+
+  EngineOpWorker(Napi::Env env, Napi::Object owner, std::function<void()> op,
+                 OnSettled onSettled)
+      : Napi::AsyncWorker(env),
+        deferred_(Napi::Promise::Deferred::New(env)),
+        op_(std::move(op)),
+        onSettled_(std::move(onSettled)) {
+    ownerRef_ = Napi::Persistent(owner);
+  }
+
+  Napi::Promise Promise() { return deferred_.Promise(); }
+
+  // Runs on a libuv worker thread. NO Napi/JS access allowed here.
+  void Execute() override {
+    try {
+      op_();
+    } catch (const std::exception& e) {
+      err_.Capture(e);
+    } catch (...) {
+      err_.has = true;
+      err_.message = "unknown native error";
+      err_.fixErrorName = "Error";
+    }
+  }
+
+  // Runs on the JS thread.
+  void OnOK() override {
+    Napi::HandleScope scope(Env());
+    Dispatch();
+  }
+
+  // Runs on the JS thread (only if AsyncWorker::SetError was used; we don't, so
+  // errors flow through OnOK — but provide OnError for completeness/safety).
+  void OnError(const Napi::Error& e) override {
+    Napi::HandleScope scope(Env());
+    err_.has = true;
+    err_.message = e.Message();
+    err_.fixErrorName = "Error";
+    Dispatch();
+  }
+
+ private:
+  void Dispatch() {
+    const bool ok = !err_.has;
+    auto settlement = std::make_shared<Settlement>(
+        std::move(deferred_), std::move(ownerRef_), std::move(err_));
+    if (onSettled_) {
+      onSettled_(ok, settlement);
+    } else {
+      settlement->Settle();
+    }
+  }
+
+  Napi::Promise::Deferred deferred_;
+  Napi::ObjectReference ownerRef_;
+  std::function<void()> op_;
+  OnSettled onSettled_;
+  CapturedError err_;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_ENGINE_WORKERS_H

package/cpp/errors.h

@@ -0,0 +1,142 @@
+// C++ -> Napi::Error translation for the QuickFIX wrapper.
+//
+// Every wrapper method funnels caught exceptions through here so that JS sees a
+// consistent Error shape:
+//   - name:     "QuickFixError"
+//   - message:  the exception's what()
+//   - fixError: a discriminator string. For FIX::Exception this is its `.type`
+//               (e.g. "Field not found: 35", "Configuration failed", ...) which
+//               is stable per concrete type; we ALSO set fixErrorName to the C++
+//               class name (e.g. "FieldNotFound") which is the value TS keys on.
+//   - detail:   the exception's `.detail` when available.
+//
+// NAPI_CPP_EXCEPTIONS is enabled, so throwing a Napi::Error unwinds into a JS
+// throw at the call boundary.
+#ifndef NAPI_QUICKFIX_ERRORS_H
+#define NAPI_QUICKFIX_ERRORS_H
+
+#include <napi.h>
+
+#include <exception>
+#include <string>
+
+#include "quickfix/Exceptions.h"
+
+namespace napi_quickfix {
+
+// Map a concrete FIX::Exception to a stable class-name discriminator. QuickFIX
+// exceptions don't carry RTTI-friendly names, so we dynamic_cast the well-known
+// concrete types (order: most-specific first is not required since they don't
+// inherit from each other beyond Exception).
+inline const char* FixErrorName(const FIX::Exception& e) {
+  if (dynamic_cast<const FIX::ConfigError*>(&e)) return "ConfigError";
+  if (dynamic_cast<const FIX::RuntimeError*>(&e)) return "RuntimeError";
+  if (dynamic_cast<const FIX::FieldNotFound*>(&e)) return "FieldNotFound";
+  if (dynamic_cast<const FIX::FieldConvertError*>(&e)) return "FieldConvertError";
+  if (dynamic_cast<const FIX::MessageParseError*>(&e)) return "MessageParseError";
+  if (dynamic_cast<const FIX::InvalidMessage*>(&e)) return "InvalidMessage";
+  if (dynamic_cast<const FIX::IncorrectDataFormat*>(&e)) return "IncorrectDataFormat";
+  if (dynamic_cast<const FIX::IncorrectTagValue*>(&e)) return "IncorrectTagValue";
+  if (dynamic_cast<const FIX::IncorrectMessageStructure*>(&e)) return "IncorrectMessageStructure";
+  if (dynamic_cast<const FIX::InvalidTagNumber*>(&e)) return "InvalidTagNumber";
+  if (dynamic_cast<const FIX::RequiredTagMissing*>(&e)) return "RequiredTagMissing";
+  if (dynamic_cast<const FIX::TagNotDefinedForMessage*>(&e)) return "TagNotDefinedForMessage";
+  if (dynamic_cast<const FIX::NoTagValue*>(&e)) return "NoTagValue";
+  if (dynamic_cast<const FIX::DuplicateFieldNumber*>(&e)) return "DuplicateFieldNumber";
+  if (dynamic_cast<const FIX::InvalidMessageType*>(&e)) return "InvalidMessageType";
+  if (dynamic_cast<const FIX::UnsupportedMessageType*>(&e)) return "UnsupportedMessageType";
+  if (dynamic_cast<const FIX::UnsupportedVersion*>(&e)) return "UnsupportedVersion";
+  if (dynamic_cast<const FIX::TagOutOfOrder*>(&e)) return "TagOutOfOrder";
+  if (dynamic_cast<const FIX::RepeatedTag*>(&e)) return "RepeatedTag";
+  if (dynamic_cast<const FIX::RepeatingGroupCountMismatch*>(&e)) return "RepeatingGroupCountMismatch";
+  if (dynamic_cast<const FIX::DoNotSend*>(&e)) return "DoNotSend";
+  if (dynamic_cast<const FIX::RejectLogon*>(&e)) return "RejectLogon";
+  if (dynamic_cast<const FIX::SessionNotFound*>(&e)) return "SessionNotFound";
+  if (dynamic_cast<const FIX::DataDictionaryNotFound*>(&e)) return "DataDictionaryNotFound";
+  if (dynamic_cast<const FIX::IOException*>(&e)) return "IOException";
+  if (dynamic_cast<const FIX::SocketException*>(&e)) return "SocketException";
+  return "FixException";
+}
+
+// Build (but do not throw) a Napi::Error from a FIX::Exception.
+inline Napi::Error MakeFixError(Napi::Env env, const FIX::Exception& e) {
+  Napi::Error err = Napi::Error::New(env, e.what());
+  err.Set("name", Napi::String::New(env, "QuickFixError"));
+  err.Set("fixError", Napi::String::New(env, e.type));
+  err.Set("fixErrorName", Napi::String::New(env, FixErrorName(e)));
+  err.Set("detail", Napi::String::New(env, e.detail));
+  return err;
+}
+
+// Build (but do not throw) a Napi::Error from a generic std::exception.
+inline Napi::Error MakeStdError(Napi::Env env, const std::exception& e) {
+  Napi::Error err = Napi::Error::New(env, e.what());
+  err.Set("name", Napi::String::New(env, "QuickFixError"));
+  err.Set("fixErrorName", Napi::String::New(env, "Error"));
+  return err;
+}
+
+// A plain-data capture of an exception's mapped fields, safe to carry across
+// threads (an AsyncWorker's Execute() runs off the JS thread and MUST NOT touch
+// Napi/JS). Populate it in a catch block on the worker thread, then rebuild a
+// Napi::Error from it in OnError/OnOK (which run on the JS thread).
+struct CapturedError {
+  bool has = false;
+  bool isFix = false;
+  std::string message;       // what()
+  std::string fixError;      // FIX::Exception::type (for FIX exceptions)
+  std::string fixErrorName;  // stable class-name discriminator
+  std::string detail;        // FIX::Exception::detail
+
+  void Capture(const std::exception& e) {
+    has = true;
+    message = e.what();
+    if (const auto* fe = dynamic_cast<const FIX::Exception*>(&e)) {
+      isFix = true;
+      fixError = fe->type;
+      fixErrorName = FixErrorName(*fe);
+      detail = fe->detail;
+    } else {
+      isFix = false;
+      fixErrorName = "Error";
+    }
+  }
+
+  // Build (do not throw) a Napi::Error from the captured fields.
+  Napi::Error ToError(Napi::Env env) const {
+    Napi::Error err = Napi::Error::New(env, message);
+    err.Set("name", Napi::String::New(env, "QuickFixError"));
+    if (isFix) {
+      err.Set("fixError", Napi::String::New(env, fixError));
+      err.Set("fixErrorName", Napi::String::New(env, fixErrorName));
+      err.Set("detail", Napi::String::New(env, detail));
+    } else {
+      err.Set("fixErrorName", Napi::String::New(env, fixErrorName));
+    }
+    return err;
+  }
+};
+
+// Translate a caught exception and throw the corresponding Napi::Error. Callers
+// use this inside a catch block, e.g.:
+//   try { ... } catch (const std::exception& e) { TranslateAndThrow(env, e); }
+[[noreturn]] inline void TranslateAndThrow(Napi::Env env, const std::exception& e) {
+  if (const auto* fe = dynamic_cast<const FIX::Exception*>(&e)) {
+    throw MakeFixError(env, *fe);
+  }
+  throw MakeStdError(env, e);
+}
+
+}  // namespace napi_quickfix
+
+// Wrap a QuickFIX-calling body so any std::exception is converted to a JS throw.
+// Usage:
+//   NQ_TRY(env) { ...quickfix calls that may throw... } NQ_CATCH(env)
+// The body may `return` a Napi::Value normally.
+#define NQ_TRY(env) try
+#define NQ_CATCH(env)                                                    \
+  catch (const std::exception& _nq_e) {                                  \
+    ::napi_quickfix::TranslateAndThrow((env), _nq_e);                    \
+  }
+
+#endif  // NAPI_QUICKFIX_ERRORS_H