@homaiohq/napi-quickfix 0.0.0-stage → 0.2.0

package/cpp/message_wrap.cpp

@@ -0,0 +1,288 @@
+#include "message_wrap.h"
+
+#include <algorithm>
+#include <string>
+#include <utility>
+
+#include "data_dictionary_wrap.h"
+#include "errors.h"
+#include "field_map_ops.h"
+#include "quickfix/FieldNumbers.h"
+
+namespace napi_quickfix {
+
+Napi::FunctionReference MessageWrap::constructor_;
+
+Napi::Object MessageWrap::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "Message",
+      {
+          InstanceMethod("getField", &MessageWrap::GetField),
+          InstanceMethod("setField", &MessageWrap::SetField),
+          InstanceMethod("isSetField", &MessageWrap::IsSetField),
+          InstanceMethod("removeField", &MessageWrap::RemoveField),
+          InstanceMethod("getFieldIfSet", &MessageWrap::GetFieldIfSet),
+          InstanceMethod("getHeaderField", &MessageWrap::GetHeaderField),
+          InstanceMethod("setHeaderField", &MessageWrap::SetHeaderField),
+          InstanceMethod("getTrailerField", &MessageWrap::GetTrailerField),
+          InstanceMethod("setTrailerField", &MessageWrap::SetTrailerField),
+          InstanceMethod("isEmpty", &MessageWrap::IsEmpty),
+          InstanceMethod("totalFields", &MessageWrap::TotalFields),
+          InstanceMethod("clear", &MessageWrap::Clear),
+          InstanceMethod("fields", &MessageWrap::Fields),
+          InstanceMethod("headerFields", &MessageWrap::HeaderFields),
+          InstanceMethod("trailerFields", &MessageWrap::TrailerFields),
+          InstanceMethod("addGroup", &MessageWrap::AddGroup),
+          InstanceMethod("getGroup", &MessageWrap::GetGroup),
+          InstanceMethod("replaceGroup", &MessageWrap::ReplaceGroup),
+          InstanceMethod("removeGroup", &MessageWrap::RemoveGroup),
+          InstanceMethod("hasGroup", &MessageWrap::HasGroup),
+          InstanceMethod("groupCount", &MessageWrap::GroupCount),
+          InstanceMethod("toString", &MessageWrap::ToString),
+          InstanceMethod("toPretty", &MessageWrap::ToPretty),
+          InstanceMethod("getMsgType", &MessageWrap::GetMsgType),
+      });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("MessageWrap", func);
+  return exports;
+}
+
+// Both construct an empty MessageWrap then fill its (empty) FIX::Message. A
+// move keeps the nested entries typed by itself: FieldMap's move assignment
+// takes the entry pointers over.
+Napi::Object MessageWrap::NewInstance(Napi::Env env, const FIX::Message& msg) {
+  Napi::Object obj = constructor_.New({});
+  MessageWrap* wrap = Napi::ObjectWrap<MessageWrap>::Unwrap(obj);
+  fieldmap::CloneMessage(wrap->message_, msg);
+  return obj;
+}
+
+Napi::Object MessageWrap::NewInstance(
+    Napi::Env env, FIX::Message&& msg,
+    std::shared_ptr<const FIX::DataDictionary> sessionDictionary) {
+  Napi::Object obj = constructor_.New({});
+  MessageWrap* wrap = Napi::ObjectWrap<MessageWrap>::Unwrap(obj);
+  wrap->message_ = std::move(msg);
+  wrap->sessionDictionary_ = std::move(sessionDictionary);
+  return obj;
+}
+
+MessageWrap* MessageWrap::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 Message instance");
+  }
+  return Napi::ObjectWrap<MessageWrap>::Unwrap(value.As<Napi::Object>());
+}
+
+MessageWrap::MessageWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<MessageWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() == 0) {
+    // Empty message.
+    return;
+  }
+  if (!info[0].IsString()) {
+    throw Napi::TypeError::New(
+        env,
+        "new Message(raw: string, validate?: boolean, "
+        "sessionDictionary?: DataDictionary, "
+        "applicationDictionary?: DataDictionary)");
+  }
+  const std::string raw = info[0].As<Napi::String>().Utf8Value();
+  bool validate = false;
+  if (info.Length() >= 2 && !fieldmap::IsNullish(info[1])) {
+    validate = info[1].ToBoolean().Value();
+  }
+  const FIX::DataDictionary* sessionDD = nullptr;
+  const FIX::DataDictionary* appDD = nullptr;
+  if (info.Length() >= 3 && !fieldmap::IsNullish(info[2])) {
+    sessionDictionary_ =
+        DataDictionaryWrap::UnwrapArg(env, info[2], "sessionDictionary")
+            ->Shared();
+    sessionDD = sessionDictionary_.get();
+  }
+  if (info.Length() >= 4 && !fieldmap::IsNullish(info[3])) {
+    appDD = &DataDictionaryWrap::UnwrapArg(env, info[3], "applicationDictionary")
+                 ->Dictionary();
+  }
+  NQ_TRY(env) {
+    if (sessionDD != nullptr || appDD != nullptr) {
+      // The dictionaries are read only during this call; the wrapper objects
+      // are kept alive by the caller's arguments for its duration.
+      message_.setString(raw, validate, sessionDD, appDD);
+    } else {
+      message_.setString(raw, validate);
+    }
+  } NQ_CATCH(env)
+}
+
+namespace {
+
+bool Holds(const FIX::FieldMap& map, int tag) {
+  return map.isSetField(tag) || map.hasGroup(tag);
+}
+
+}  // namespace
+
+// Auto-route standard header/trailer fields (MsgType, SenderCompID, CheckSum,
+// NoHops, ...) and the ones the session dictionary declares to the right
+// section, as the parser does, so callers don't have to know which section a
+// tag belongs to, and a dictionary header field that is removed and set again
+// goes back to the header. Without a dictionary (a message built in JS or
+// parsed without one), any other tag is a body field unless the header or
+// trailer already holds it, so reads find such a field and setField /
+// removeField edit it in place rather than adding a body duplicate. A tag
+// held nowhere stays a body field.
+FIX::FieldMap& MessageWrap::SectionFor(int tag) {
+  const FIX::DataDictionary* dd = sessionDictionary_.get();
+  if (FIX::Message::isHeaderField(tag, dd)) {
+    return message_.getHeader();
+  }
+  if (FIX::Message::isTrailerField(tag, dd)) {
+    return message_.getTrailer();
+  }
+  if (Holds(message_, tag)) {
+    return message_;
+  }
+  if (Holds(message_.getHeader(), tag)) {
+    return message_.getHeader();
+  }
+  if (Holds(message_.getTrailer(), tag)) {
+    return message_.getTrailer();
+  }
+  return message_;
+}
+
+#define NQ_ROUTED [this](int tag) -> FIX::FieldMap& { return SectionFor(tag); }
+#define NQ_HEADER [this](int) -> FIX::FieldMap& { return message_.getHeader(); }
+#define NQ_TRAILER [this](int) -> FIX::FieldMap& { return message_.getTrailer(); }
+
+Napi::Value MessageWrap::GetField(const Napi::CallbackInfo& info) {
+  return fieldmap::GetField(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::SetField(const Napi::CallbackInfo& info) {
+  return fieldmap::SetField(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::IsSetField(const Napi::CallbackInfo& info) {
+  return fieldmap::IsSetField(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::RemoveField(const Napi::CallbackInfo& info) {
+  return fieldmap::RemoveField(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::GetFieldIfSet(const Napi::CallbackInfo& info) {
+  return fieldmap::GetFieldIfSet(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::GetHeaderField(const Napi::CallbackInfo& info) {
+  return fieldmap::GetField(info, NQ_HEADER);
+}
+
+Napi::Value MessageWrap::SetHeaderField(const Napi::CallbackInfo& info) {
+  return fieldmap::SetField(info, NQ_HEADER);
+}
+
+Napi::Value MessageWrap::GetTrailerField(const Napi::CallbackInfo& info) {
+  return fieldmap::GetField(info, NQ_TRAILER);
+}
+
+Napi::Value MessageWrap::SetTrailerField(const Napi::CallbackInfo& info) {
+  return fieldmap::SetField(info, NQ_TRAILER);
+}
+
+// Header, body and trailer (FIX::Message::isEmpty, not FieldMap's body-only
+// one), like clear().
+Napi::Value MessageWrap::IsEmpty(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    return Napi::Boolean::New(env, message_.isEmpty());
+  } NQ_CATCH(env)
+}
+
+Napi::Value MessageWrap::TotalFields(const Napi::CallbackInfo& info) {
+  return fieldmap::TotalFields(info.Env(), message_);
+}
+
+// Empties header, body and trailer.
+Napi::Value MessageWrap::Clear(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    message_.clear();
+  } NQ_CATCH(env)
+  return env.Undefined();
+}
+
+Napi::Value MessageWrap::Fields(const Napi::CallbackInfo& info) {
+  return fieldmap::Fields(info.Env(), message_);
+}
+
+Napi::Value MessageWrap::HeaderFields(const Napi::CallbackInfo& info) {
+  return fieldmap::Fields(info.Env(), message_.getHeader());
+}
+
+Napi::Value MessageWrap::TrailerFields(const Napi::CallbackInfo& info) {
+  return fieldmap::Fields(info.Env(), message_.getTrailer());
+}
+
+Napi::Value MessageWrap::AddGroup(const Napi::CallbackInfo& info) {
+  return fieldmap::AddGroup(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::GetGroup(const Napi::CallbackInfo& info) {
+  return fieldmap::GetGroup(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::ReplaceGroup(const Napi::CallbackInfo& info) {
+  return fieldmap::ReplaceGroup(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::RemoveGroup(const Napi::CallbackInfo& info) {
+  return fieldmap::RemoveGroup(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::HasGroup(const Napi::CallbackInfo& info) {
+  return fieldmap::HasGroup(info, NQ_ROUTED);
+}
+
+Napi::Value MessageWrap::GroupCount(const Napi::CallbackInfo& info) {
+  return fieldmap::GroupCount(info, NQ_ROUTED);
+}
+
+#undef NQ_ROUTED
+#undef NQ_HEADER
+#undef NQ_TRAILER
+
+Napi::Value MessageWrap::ToString(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    return Napi::String::New(env, message_.toString());
+  } NQ_CATCH(env)
+}
+
+Napi::Value MessageWrap::ToPretty(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    std::string s = message_.toString();
+    std::replace(s.begin(), s.end(), '\x01', '|');
+    return Napi::String::New(env, s);
+  } NQ_CATCH(env)
+}
+
+Napi::Value MessageWrap::GetMsgType(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    const std::string& msgType = message_.getHeader().getField(FIX::FIELD::MsgType);
+    return Napi::String::New(env, msgType);
+  } NQ_CATCH(env)
+}
+
+}  // namespace napi_quickfix

package/cpp/message_wrap.h

@@ -0,0 +1,95 @@
+#ifndef NAPI_QUICKFIX_MESSAGE_WRAP_H
+#define NAPI_QUICKFIX_MESSAGE_WRAP_H
+
+#include <napi.h>
+
+#include <memory>
+
+#include "quickfix/DataDictionary.h"
+#include "quickfix/Message.h"
+
+namespace napi_quickfix {
+
+// Napi::ObjectWrap over FIX::Message.
+//
+//   new MessageWrap()
+//   new MessageWrap(raw: string, validate?: boolean = false,
+//                   sessionDictionary?: DataDictionary,
+//                   applicationDictionary?: DataDictionary)
+//
+// With a dictionary the raw string is parsed structurally (repeating groups
+// become nested FieldMaps); without one it is parsed flat, as before.
+//
+// Field methods (getField / setField / isSetField / removeField /
+// getFieldIfSet) and group methods (addGroup / getGroup / replaceGroup /
+// removeGroup / hasGroup / groupCount) auto-route standard header/trailer
+// tags to the right section, as well as the header/trailer fields declared by
+// the session dictionary the message was parsed or delivered with. Any other
+// tag goes to the section that already holds it (body first). isEmpty and
+// clear() cover all three sections; totalFields / fields read the body.
+class MessageWrap : public Napi::ObjectWrap<MessageWrap> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  // Build a JS MessageWrap holding a copy of `msg` (typed down to the last
+  // nested group entry, see fieldmap::CloneMessage), or taking `msg` over.
+  // The ApplicationBridge trampoline moves its own copy in, with the session
+  // dictionary that routes its fields (null: none).
+  static Napi::Object NewInstance(Napi::Env env, const FIX::Message& msg);
+  static Napi::Object NewInstance(
+      Napi::Env env, FIX::Message&& msg,
+      std::shared_ptr<const FIX::DataDictionary> sessionDictionary = nullptr);
+
+  explicit MessageWrap(const Napi::CallbackInfo& info);
+
+  // Internal accessor for other wrappers (validate, sendToTarget, bridge).
+  FIX::Message& Message() { return message_; }
+  const FIX::Message& Message() const { return message_; }
+
+  // Unwrap a JS value that must be a MessageWrap; throws Napi::TypeError if not.
+  static MessageWrap* UnwrapArg(Napi::Env env, Napi::Value value,
+                             const char* argName);
+
+ private:
+  static Napi::FunctionReference constructor_;
+
+  // The section (header / body / trailer) that owns `tag`.
+  FIX::FieldMap& SectionFor(int tag);
+
+  Napi::Value GetField(const Napi::CallbackInfo& info);
+  Napi::Value SetField(const Napi::CallbackInfo& info);
+  Napi::Value IsSetField(const Napi::CallbackInfo& info);
+  Napi::Value RemoveField(const Napi::CallbackInfo& info);
+  Napi::Value GetFieldIfSet(const Napi::CallbackInfo& info);
+  Napi::Value GetHeaderField(const Napi::CallbackInfo& info);
+  Napi::Value SetHeaderField(const Napi::CallbackInfo& info);
+  Napi::Value GetTrailerField(const Napi::CallbackInfo& info);
+  Napi::Value SetTrailerField(const Napi::CallbackInfo& info);
+  Napi::Value IsEmpty(const Napi::CallbackInfo& info);
+  Napi::Value TotalFields(const Napi::CallbackInfo& info);
+  Napi::Value Clear(const Napi::CallbackInfo& info);
+  Napi::Value Fields(const Napi::CallbackInfo& info);
+  Napi::Value HeaderFields(const Napi::CallbackInfo& info);
+  Napi::Value TrailerFields(const Napi::CallbackInfo& info);
+
+  Napi::Value AddGroup(const Napi::CallbackInfo& info);
+  Napi::Value GetGroup(const Napi::CallbackInfo& info);
+  Napi::Value ReplaceGroup(const Napi::CallbackInfo& info);
+  Napi::Value RemoveGroup(const Napi::CallbackInfo& info);
+  Napi::Value HasGroup(const Napi::CallbackInfo& info);
+  Napi::Value GroupCount(const Napi::CallbackInfo& info);
+
+  Napi::Value ToString(const Napi::CallbackInfo& info);
+  Napi::Value ToPretty(const Napi::CallbackInfo& info);
+  Napi::Value GetMsgType(const Napi::CallbackInfo& info);
+
+  FIX::Message message_;
+  // The session dictionary whose header/trailer fields SectionFor routes
+  // (null: none). Shared, since the message may outlive the session or the
+  // JS DataDictionary it came from.
+  std::shared_ptr<const FIX::DataDictionary> sessionDictionary_;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_MESSAGE_WRAP_H

package/cpp/session_id_wrap.cpp

@@ -0,0 +1,91 @@
+#include "session_id_wrap.h"
+
+#include <string>
+
+#include "errors.h"
+
+namespace napi_quickfix {
+
+Napi::FunctionReference SessionIDWrap::constructor_;
+
+Napi::Object SessionIDWrap::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "SessionID",
+      {
+          InstanceMethod("getBeginString", &SessionIDWrap::GetBeginString),
+          InstanceMethod("getSenderCompID", &SessionIDWrap::GetSenderCompID),
+          InstanceMethod("getTargetCompID", &SessionIDWrap::GetTargetCompID),
+          InstanceMethod("getSessionQualifier",
+                         &SessionIDWrap::GetSessionQualifier),
+          InstanceMethod("toString", &SessionIDWrap::ToString),
+      });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("SessionIDWrap", func);
+  return exports;
+}
+
+Napi::Object SessionIDWrap::NewInstance(Napi::Env env,
+                                        const FIX::SessionID& id) {
+  Napi::Object obj = constructor_.New(
+      {Napi::String::New(env, id.getBeginString().getValue()),
+       Napi::String::New(env, id.getSenderCompID().getValue()),
+       Napi::String::New(env, id.getTargetCompID().getValue()),
+       Napi::String::New(env, id.getSessionQualifier())});
+  return obj;
+}
+
+SessionIDWrap* SessionIDWrap::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 SessionID instance");
+  }
+  return Napi::ObjectWrap<SessionIDWrap>::Unwrap(value.As<Napi::Object>());
+}
+
+SessionIDWrap::SessionIDWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<SessionIDWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() ||
+      !info[2].IsString()) {
+    throw Napi::TypeError::New(
+        env,
+        "new SessionID(beginString, senderCompID, targetCompID, qualifier?)");
+  }
+  std::string begin = info[0].As<Napi::String>().Utf8Value();
+  std::string sender = info[1].As<Napi::String>().Utf8Value();
+  std::string target = info[2].As<Napi::String>().Utf8Value();
+  std::string qualifier;
+  if (info.Length() >= 4 && info[3].IsString()) {
+    qualifier = info[3].As<Napi::String>().Utf8Value();
+  }
+  session_id_ = FIX::SessionID(begin, sender, target, qualifier);
+}
+
+Napi::Value SessionIDWrap::GetBeginString(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), session_id_.getBeginString().getValue());
+}
+
+Napi::Value SessionIDWrap::GetSenderCompID(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(),
+                           session_id_.getSenderCompID().getValue());
+}
+
+Napi::Value SessionIDWrap::GetTargetCompID(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(),
+                           session_id_.getTargetCompID().getValue());
+}
+
+Napi::Value SessionIDWrap::GetSessionQualifier(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), session_id_.getSessionQualifier());
+}
+
+Napi::Value SessionIDWrap::ToString(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), session_id_.toString());
+}
+
+}  // namespace napi_quickfix

package/cpp/session_id_wrap.h

@@ -0,0 +1,46 @@
+#ifndef NAPI_QUICKFIX_SESSION_ID_WRAP_H
+#define NAPI_QUICKFIX_SESSION_ID_WRAP_H
+
+#include <napi.h>
+
+#include "quickfix/SessionID.h"
+
+namespace napi_quickfix {
+
+// Napi::ObjectWrap over FIX::SessionID.
+//
+//   new SessionID(beginString, senderCompID, targetCompID, qualifier?)
+//
+// Getters: getBeginString / getSenderCompID / getTargetCompID /
+// getSessionQualifier; plus toString.
+class SessionIDWrap : public Napi::ObjectWrap<SessionIDWrap> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  // Build a JS SessionID wrapping a copy of the given FIX::SessionID.
+  static Napi::Object NewInstance(Napi::Env env, const FIX::SessionID& id);
+
+  explicit SessionIDWrap(const Napi::CallbackInfo& info);
+
+  FIX::SessionID& SessionID() { return session_id_; }
+  const FIX::SessionID& SessionID() const { return session_id_; }
+
+  // Unwrap a JS value that must be a SessionID; throws Napi::TypeError if not.
+  static SessionIDWrap* UnwrapArg(Napi::Env env, Napi::Value value,
+                               const char* argName);
+
+ private:
+  static Napi::FunctionReference constructor_;
+
+  Napi::Value GetBeginString(const Napi::CallbackInfo& info);
+  Napi::Value GetSenderCompID(const Napi::CallbackInfo& info);
+  Napi::Value GetTargetCompID(const Napi::CallbackInfo& info);
+  Napi::Value GetSessionQualifier(const Napi::CallbackInfo& info);
+  Napi::Value ToString(const Napi::CallbackInfo& info);
+
+  FIX::SessionID session_id_;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_SESSION_ID_WRAP_H