@technoculture/data-bridge 0.1.1 → 0.1.2

package/src/addon.cpp

@@ -2,7 +2,10 @@
  * Data Bridge Node.js Native Addon
  * 
  * Exposes the C++ Data Bridge library to JavaScript via Node-API.
- * Provides async-safe wrappers for serial port operations.
+ * Aligned with Python _core:
+ * - SerialPort: Raw async serial I/O
+ * - Packet: Serialization/Deserialization helpers
+ * - Reassembler: Fragmentation handling
  */
 
 #include <napi.h>
@@ -12,208 +15,316 @@
 #include <memory>
 #include <thread>
 #include <atomic>
-#include <queue>
-#include <mutex>
-#include <condition_variable>
+#include <vector>
 
-class DataBridgeWrapper : public Napi::ObjectWrap<DataBridgeWrapper> {
+// --- SerialPort Wrapper ---
+class SerialPortWrapper : public Napi::ObjectWrap<SerialPortWrapper> {
 public:
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
-    DataBridgeWrapper(const Napi::CallbackInfo& info);
-    ~DataBridgeWrapper();
+    SerialPortWrapper(const Napi::CallbackInfo& info);
+    ~SerialPortWrapper();
 
 private:
-    // JavaScript methods
     Napi::Value Open(const Napi::CallbackInfo& info);
-    Napi::Value Send(const Napi::CallbackInfo& info);
     Napi::Value Close(const Napi::CallbackInfo& info);
+    Napi::Value Write(const Napi::CallbackInfo& info);
     Napi::Value IsOpen(const Napi::CallbackInfo& info);
-    
-    // Internal state
+
     std::unique_ptr<SerialPort> serial_;
     std::atomic<bool> is_open_{false};
     std::atomic<bool> should_stop_{false};
     std::thread receive_thread_;
-    uint8_t seq_id_ = 0;  // Per-instance sequence ID
-    
-    // Thread-safe receive callback
     Napi::ThreadSafeFunction tsfn_;
-    
+
     void ReceiveLoop();
     void StopReceiveLoop();
 };
 
-Napi::Object DataBridgeWrapper::Init(Napi::Env env, Napi::Object exports) {
-    Napi::Function func = DefineClass(env, "DataBridge", {
-        InstanceMethod("open", &DataBridgeWrapper::Open),
-        InstanceMethod("send", &DataBridgeWrapper::Send),
-        InstanceMethod("close", &DataBridgeWrapper::Close),
-        InstanceMethod("isOpen", &DataBridgeWrapper::IsOpen),
+Napi::Object SerialPortWrapper::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "SerialPort", {
+        InstanceMethod("open", &SerialPortWrapper::Open),
+        InstanceMethod("close", &SerialPortWrapper::Close),
+        InstanceMethod("write", &SerialPortWrapper::Write),
+        InstanceMethod("isOpen", &SerialPortWrapper::IsOpen),
     });
-
-    exports.Set("DataBridge", func);
+    exports.Set("SerialPort", func);
     return exports;
 }
 
-DataBridgeWrapper::DataBridgeWrapper(const Napi::CallbackInfo& info) 
-    : Napi::ObjectWrap<DataBridgeWrapper>(info) {
+SerialPortWrapper::SerialPortWrapper(const Napi::CallbackInfo& info) 
+    : Napi::ObjectWrap<SerialPortWrapper>(info) {
     serial_ = std::make_unique<SerialPort>();
 }
 
-DataBridgeWrapper::~DataBridgeWrapper() {
+SerialPortWrapper::~SerialPortWrapper() {
     StopReceiveLoop();
 }
 
-Napi::Value DataBridgeWrapper::Open(const Napi::CallbackInfo& info) {
+Napi::Value SerialPortWrapper::Open(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-    
     if (info.Length() < 1 || !info[0].IsString()) {
         Napi::TypeError::New(env, "Port path required").ThrowAsJavaScriptException();
         return env.Undefined();
     }
-    
+
     std::string port = info[0].As<Napi::String>().Utf8Value();
     int baud = 115200;
-    
-    if (info.Length() >= 2 && info[1].IsNumber()) {
-        baud = info[1].As<Napi::Number>().Int32Value();
+    if (info.Length() >= 2 && info[1].IsNumber()) baud = info[1].As<Napi::Number>().Int32Value();
+
+    // Callback is mandatory for raw serial port to receive data
+    if (info.Length() < 3 || !info[2].IsFunction()) {
+        Napi::TypeError::New(env, "Callback required").ThrowAsJavaScriptException();
+        return env.Undefined();
     }
-    
-    // Create a deferred promise
-    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
-    
+
     if (serial_->open(port, baud)) {
         is_open_ = true;
         
-        // Setup receive callback if provided
-        if (info.Length() >= 3 && info[2].IsFunction()) {
-            tsfn_ = Napi::ThreadSafeFunction::New(
-                env,
-                info[2].As<Napi::Function>(),
-                "DataBridge Receive Callback",
-                0, 1
-            );
-            
-            should_stop_ = false;
-            receive_thread_ = std::thread(&DataBridgeWrapper::ReceiveLoop, this);
-        }
+        tsfn_ = Napi::ThreadSafeFunction::New(
+            env,
+            info[2].As<Napi::Function>(),
+            "SerialPort Receive Callback",
+            0, 1
+        );
         
-        deferred.Resolve(Napi::Boolean::New(env, true));
-    } else {
-        deferred.Reject(Napi::Error::New(env, "Failed to open port: " + port).Value());
+        should_stop_ = false;
+        receive_thread_ = std::thread(&SerialPortWrapper::ReceiveLoop, this);
+        
+        return Napi::Boolean::New(env, true);
     }
     
-    return deferred.Promise();
+    return Napi::Boolean::New(env, false);
+}
+
+Napi::Value SerialPortWrapper::Close(const Napi::CallbackInfo& info) {
+    StopReceiveLoop();
+    serial_->close();
+    is_open_ = false;
+    return Napi::Boolean::New(info.Env(), true);
 }
 
-Napi::Value DataBridgeWrapper::Send(const Napi::CallbackInfo& info) {
+Napi::Value SerialPortWrapper::Write(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-    
-    if (!is_open_) {
-        Napi::Error::New(env, "Port not open").ThrowAsJavaScriptException();
+    if (info.Length() < 1 || !info[0].IsBuffer()) {
+        Napi::TypeError::New(env, "Buffer required").ThrowAsJavaScriptException();
         return env.Undefined();
     }
-    
-    if (info.Length() < 1) {
-        Napi::TypeError::New(env, "Data required").ThrowAsJavaScriptException();
-        return env.Undefined();
-    }
-    
-    std::string payload;
-    if (info[0].IsBuffer()) {
-        Napi::Buffer<char> buf = info[0].As<Napi::Buffer<char>>();
-        payload = std::string(buf.Data(), buf.Length());
-    } else if (info[0].IsString()) {
-        payload = info[0].As<Napi::String>().Utf8Value();
-    } else {
-        Napi::TypeError::New(env, "Data must be Buffer or string").ThrowAsJavaScriptException();
-        return env.Undefined();
-    }
-    
-    // Serialize and send with fragmentation
-    // Sequence ID is managed per-instance
-    auto packet = Packet::serialize(Packet::TYPE_DATA, seq_id_++, payload);
-    
-    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
-    
-    // TODO: Implement proper async send with ACK waiting
-    // For now, synchronous send
-    int written = serial_->write(packet);
-    
-    if (written > 0) {
-        deferred.Resolve(Napi::Number::New(env, written));
-    } else {
-        deferred.Reject(Napi::Error::New(env, "Write failed").Value());
-    }
-    
-    return deferred.Promise();
-}
 
-Napi::Value DataBridgeWrapper::Close(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    StopReceiveLoop();
-    serial_->close();
-    is_open_ = false;
-    
-    return Napi::Boolean::New(env, true);
+    Napi::Buffer<uint8_t> buf = info[0].As<Napi::Buffer<uint8_t>>();
+    std::vector<uint8_t> data(buf.Data(), buf.Data() + buf.Length());
+
+    // Write is synchronous in C++ implementation usually, or we can make it async if needed.
+    // For now, keeping it synchronous/blocking for simplicity as per Python binding.
+    // (Node.js event loop might block briefly, but serial write is fast or buffered)
+    int written = serial_->write(data);
+    return Napi::Number::New(env, written);
 }
 
-Napi::Value DataBridgeWrapper::IsOpen(const Napi::CallbackInfo& info) {
+Napi::Value SerialPortWrapper::IsOpen(const Napi::CallbackInfo& info) {
     return Napi::Boolean::New(info.Env(), is_open_.load());
 }
 
-void DataBridgeWrapper::ReceiveLoop() {
-    uint8_t buffer[1024];
-    std::vector<uint8_t> rx_pool;
-    Reassembler reassembler;
-    
+void SerialPortWrapper::ReceiveLoop() {
+    uint8_t buffer[4096];
     while (!should_stop_) {
+        // Read raw bytes
         int n = serial_->read(buffer, sizeof(buffer));
         if (n > 0) {
-            rx_pool.insert(rx_pool.end(), buffer, buffer + n);
+            // Copy data for the callback
+            std::vector<uint8_t> data(buffer, buffer + n);
+            
+            auto status = tsfn_.BlockingCall([data](Napi::Env env, Napi::Function callback) {
+                callback.Call({
+                    Napi::Buffer<uint8_t>::Copy(env, data.data(), data.size())
+                });
+            });
             
-            while (true) {
-                auto frame = Packet::deserialize(rx_pool);
-                if (!frame.valid) break;
-                
-                if (frame.header.type == Packet::TYPE_DATA) {
-                    if (reassembler.process_fragment(frame)) {
-                        if (reassembler.is_complete(frame)) {
-                            // Emit to JavaScript via ThreadSafeFunction
-                            auto data = reassembler.get_data();
-                            
-                            tsfn_.BlockingCall([data](Napi::Env env, Napi::Function callback) {
-                                callback.Call({
-                                    Napi::Buffer<char>::Copy(env, 
-                                        reinterpret_cast<const char*>(data.data()), 
-                                        data.size())
-                                });
-                            });
-                        }
-                    }
-                    // Send ACK
-                    serial_->write(Packet::serialize(Packet::TYPE_ACK, frame.header.seq_id, ""));
-                }
-            }
+            if (status != napi_ok) break;
         }
+        // Small sleep to prevent tight loop if read is non-blocking and returns 0 often
+        // But read should be blocking with timeout.
+        // Assuming implementation of serial_->read handles timeout or blocking.
+        // The previous implementation had a sleep, so we surely need one if non-blocking.
         std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
 }
 
-void DataBridgeWrapper::StopReceiveLoop() {
+void SerialPortWrapper::StopReceiveLoop() {
     should_stop_ = true;
-    if (receive_thread_.joinable()) {
-        receive_thread_.join();
-    }
-    if (tsfn_) {
-        tsfn_.Release();
+    if (receive_thread_.joinable()) receive_thread_.join();
+    if (tsfn_) tsfn_.Release();
+}
+
+// --- Packet Wrapper ---
+class PacketWrapper : public Napi::ObjectWrap<PacketWrapper> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    PacketWrapper(const Napi::CallbackInfo& info);
+
+private:
+    static Napi::Value Serialize(const Napi::CallbackInfo& info);
+    static Napi::Value Deserialize(const Napi::CallbackInfo& info);
+};
+
+Napi::Object PacketWrapper::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "Packet", {
+        StaticMethod("serialize", &PacketWrapper::Serialize),
+        StaticMethod("deserialize", &PacketWrapper::Deserialize),
+        StaticValue("TYPE_DATA", Napi::Number::New(env, Packet::TYPE_DATA)),
+        StaticValue("TYPE_ACK", Napi::Number::New(env, Packet::TYPE_ACK)),
+        StaticValue("TYPE_NACK", Napi::Number::New(env, Packet::TYPE_NACK)),
+        StaticValue("TYPE_SYN", Napi::Number::New(env, Packet::TYPE_SYN)),
+    });
+    exports.Set("Packet", func);
+    return exports;
+}
+
+PacketWrapper::PacketWrapper(const Napi::CallbackInfo& info) : Napi::ObjectWrap<PacketWrapper>(info) {}
+
+Napi::Value PacketWrapper::Serialize(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    // Args: type, seq, payload, frag_id (opt), total_frags (opt)
+    
+    if (info.Length() < 3) throw Napi::Error::New(env, "Args: type, seq, payload");
+
+    uint8_t type = info[0].As<Napi::Number>().Uint32Value();
+    uint8_t seq = info[1].As<Napi::Number>().Uint32Value();
+    std::string payload;
+
+    if (info[2].IsBuffer()) {
+        Napi::Buffer<char> buf = info[2].As<Napi::Buffer<char>>();
+        payload.assign(buf.Data(), buf.Length());
+    } else {
+        payload = info[2].ToString().Utf8Value();
     }
+
+    uint16_t frag_id = 0;
+    uint16_t total_frags = 1;
+    if (info.Length() > 3) frag_id = info[3].As<Napi::Number>().Uint32Value();
+    if (info.Length() > 4) total_frags = info[4].As<Napi::Number>().Uint32Value();
+
+    auto vec = Packet::serialize(type, seq, payload, frag_id, total_frags);
+    return Napi::Buffer<uint8_t>::Copy(env, vec.data(), vec.size());
+}
+
+Napi::Value PacketWrapper::Deserialize(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsBuffer()) throw Napi::Error::New(env, "Buffer required");
+
+    Napi::Buffer<uint8_t> buf = info[0].As<Napi::Buffer<uint8_t>>();
+    std::vector<uint8_t> data(buf.Data(), buf.Data() + buf.Length());
+
+    // Packet::deserialize modifies the vector (consumes bytes)
+    Packet::Frame frame = Packet::deserialize(data);
+
+    Napi::Object result = Napi::Object::New(env);
+    
+    // Frame object
+    Napi::Object frameObj = Napi::Object::New(env);
+    frameObj.Set("valid", frame.valid);
+    
+    // Header
+    Napi::Object header = Napi::Object::New(env);
+    header.Set("type", frame.header.type);
+    header.Set("seq_id", frame.header.seq_id);
+    header.Set("fragment_id", frame.header.fragment_id);
+    header.Set("total_frags", frame.header.total_frags);
+    header.Set("payload_len", frame.header.payload_len);
+    header.Set("crc32", frame.header.crc32);
+    frameObj.Set("header", header);
+
+    // Payload
+    frameObj.Set("payload", Napi::Buffer<uint8_t>::Copy(env, frame.payload.data(), frame.payload.size()));
+
+    result.Set("frame", frameObj);
+    result.Set("remaining", Napi::Buffer<uint8_t>::Copy(env, data.data(), data.size()));
+
+    return result;
+}
+
+// --- Reassembler Wrapper ---
+class ReassemblerWrapper : public Napi::ObjectWrap<ReassemblerWrapper> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    ReassemblerWrapper(const Napi::CallbackInfo& info);
+
+private:
+    std::unique_ptr<Reassembler> reassembler_;
+    
+    Napi::Value ProcessFragment(const Napi::CallbackInfo& info);
+    Napi::Value IsComplete(const Napi::CallbackInfo& info);
+    Napi::Value GetData(const Napi::CallbackInfo& info);
+    Napi::Value IsDuplicate(const Napi::CallbackInfo& info);
+    Napi::Value GetBufferedSize(const Napi::CallbackInfo& info);
+};
+
+Napi::Object ReassemblerWrapper::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "Reassembler", {
+        InstanceMethod("processFragment", &ReassemblerWrapper::ProcessFragment),
+        InstanceMethod("isComplete", &ReassemblerWrapper::IsComplete),
+        InstanceMethod("getData", &ReassemblerWrapper::GetData),
+        InstanceMethod("isDuplicate", &ReassemblerWrapper::IsDuplicate),
+        InstanceMethod("getBufferedSize", &ReassemblerWrapper::GetBufferedSize),
+    });
+    exports.Set("Reassembler", func);
+    return exports;
+}
+
+ReassemblerWrapper::ReassemblerWrapper(const Napi::CallbackInfo& info) : Napi::ObjectWrap<ReassemblerWrapper>(info) {
+    reassembler_ = std::make_unique<Reassembler>();
+}
+
+// Helper to extract C++ Frame from JS Frame object
+Packet::Frame JsToFrame(Napi::Object jsFrame) {
+    Packet::Frame frame;
+    frame.valid = jsFrame.Get("valid").As<Napi::Boolean>().Value();
+    Napi::Object header = jsFrame.Get("header").As<Napi::Object>();
+    frame.header.type = header.Get("type").As<Napi::Number>().Uint32Value();
+    frame.header.seq_id = header.Get("seq_id").As<Napi::Number>().Uint32Value();
+    frame.header.fragment_id = header.Get("fragment_id").As<Napi::Number>().Uint32Value();
+    frame.header.total_frags = header.Get("total_frags").As<Napi::Number>().Uint32Value();
+    
+    Napi::Buffer<uint8_t> pl = jsFrame.Get("payload").As<Napi::Buffer<uint8_t>>();
+    frame.payload.assign(pl.Data(), pl.Data() + pl.Length());
+    return frame;
 }
 
-// Module initialization
+Napi::Value ReassemblerWrapper::ProcessFragment(const Napi::CallbackInfo& info) {
+    if (info.Length() < 1 || !info[0].IsObject()) throw Napi::Error::New(info.Env(), "Frame object required");
+    Packet::Frame frame = JsToFrame(info[0].As<Napi::Object>());
+    return Napi::Boolean::New(info.Env(), reassembler_->process_fragment(frame));
+}
+
+Napi::Value ReassemblerWrapper::IsComplete(const Napi::CallbackInfo& info) {
+    if (info.Length() < 1 || !info[0].IsObject()) throw Napi::Error::New(info.Env(), "Frame object required");
+    Packet::Frame frame = JsToFrame(info[0].As<Napi::Object>());
+    return Napi::Boolean::New(info.Env(), reassembler_->is_complete(frame));
+}
+
+Napi::Value ReassemblerWrapper::GetData(const Napi::CallbackInfo& info) {
+    auto data = reassembler_->get_data();
+    return Napi::Buffer<uint8_t>::Copy(info.Env(), data.data(), data.size());
+}
+
+Napi::Value ReassemblerWrapper::IsDuplicate(const Napi::CallbackInfo& info) {
+    if (info.Length() < 1 || !info[0].IsObject()) throw Napi::Error::New(info.Env(), "Frame object required");
+    Packet::Frame frame = JsToFrame(info[0].As<Napi::Object>());
+    return Napi::Boolean::New(info.Env(), reassembler_->is_duplicate(frame));
+}
+
+Napi::Value ReassemblerWrapper::GetBufferedSize(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), reassembler_->get_buffered_size());
+}
+
+
+// --- Init ---
+
 Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
-    return DataBridgeWrapper::Init(env, exports);
+    SerialPortWrapper::Init(env, exports);
+    PacketWrapper::Init(env, exports);
+    ReassemblerWrapper::Init(env, exports);
+    return exports;
 }
 
 NODE_API_MODULE(data_bridge_node, InitAll)
+

package/prebuilds/darwin-arm64/.ninja_log

@@ -1,6 +0,0 @@
-# ninja log v6
-1	42	1767813639052166764	CMakeFiles/data_bridge_node.dir/Users/satyamtiwary/Documents/Python-Things/data-bridge/src/protocol/crc16.cpp.o	44a8848073165fd4
-1	286	1767813639052016345	CMakeFiles/data_bridge_node.dir/src/serial_wrapper.cpp.o	9b7a8f38fa1f98b2
-1	301	1767813639052311933	CMakeFiles/data_bridge_node.dir/Users/satyamtiwary/Documents/Python-Things/data-bridge/src/transport/platform/linux/linux_serial.cpp.o	1a4595fea1e208f8
-1	698	1767813639051708840	CMakeFiles/data_bridge_node.dir/src/addon.cpp.o	7d74cb8705ae44b7
-698	745	1767813639749307606	Release/data_bridge_node.node	1305e389db74efac