starpc 0.43.1 → 0.45.0

package/mock/mock_srpc.pb.hpp

@@ -0,0 +1,104 @@
+// Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
+// protoc-gen-starpc-cpp version: v0.43.2-0.20260131104303-1de77bff6409+dirty
+// source: github.com/aperturerobotics/starpc/mock/mock.proto
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "srpc/starpc.hpp"
+
+#include "mock.pb.h"
+
+namespace e2e::mock {
+
+// Service ID for Mock
+constexpr const char *kSRPCMockServiceID = "e2e.mock.Mock";
+
+// SRPCMockClient is the client API for Mock service.
+class SRPCMockClient {
+public:
+  virtual ~SRPCMockClient() = default;
+
+  // SRPCClient returns the underlying SRPC client.
+  virtual starpc::Client *SRPCClient() = 0;
+
+  // MockRequest
+  virtual starpc::Error MockRequest(const e2e::mock::MockMsg &in,
+                                    e2e::mock::MockMsg *out) = 0;
+};
+
+// SRPCMockClientImpl implements SRPCMockClient.
+class SRPCMockClientImpl : public SRPCMockClient {
+public:
+  explicit SRPCMockClientImpl(starpc::Client *cc,
+                              const std::string &service_id = "")
+      : cc_(cc),
+        service_id_(service_id.empty() ? kSRPCMockServiceID : service_id) {}
+
+  starpc::Client *SRPCClient() override { return cc_; }
+
+  // MockRequest
+  virtual starpc::Error MockRequest(const e2e::mock::MockMsg &in,
+                                    e2e::mock::MockMsg *out) override;
+
+private:
+  starpc::Client *cc_;
+  std::string service_id_;
+};
+
+// NewSRPCMockClient creates a new client.
+inline std::unique_ptr<SRPCMockClient> NewSRPCMockClient(starpc::Client *cc) {
+  return std::make_unique<SRPCMockClientImpl>(cc);
+}
+
+// SRPCMockServer is the server API for Mock service.
+class SRPCMockServer {
+public:
+  virtual ~SRPCMockServer() = default;
+
+  // MockRequest
+  virtual starpc::Error MockRequest(const e2e::mock::MockMsg &req,
+                                    e2e::mock::MockMsg *resp) = 0;
+};
+
+// SRPCMockHandler implements starpc::Handler for Mock.
+class SRPCMockHandler : public starpc::Handler {
+public:
+  SRPCMockHandler(SRPCMockServer *impl, const std::string &service_id = "")
+      : impl_(impl),
+        service_id_(service_id.empty() ? kSRPCMockServiceID : service_id) {}
+
+  const std::string &GetServiceID() const override { return service_id_; }
+  std::vector<std::string> GetMethodIDs() const override;
+  std::pair<bool, starpc::Error> InvokeMethod(const std::string &service_id,
+                                              const std::string &method_id,
+                                              starpc::Stream *strm) override;
+
+private:
+  SRPCMockServer *impl_;
+  std::string service_id_;
+};
+
+// NewSRPCMockHandler creates a new handler for the given implementation.
+inline std::unique_ptr<SRPCMockHandler>
+NewSRPCMockHandler(SRPCMockServer *impl) {
+  return std::make_unique<SRPCMockHandler>(impl);
+}
+
+// SRPCRegisterMock registers the server implementation with the mux.
+// The returned handler must outlive the mux registration.
+inline std::pair<std::unique_ptr<SRPCMockHandler>, starpc::Error>
+SRPCRegisterMock(starpc::Mux *mux, SRPCMockServer *impl) {
+  auto handler = NewSRPCMockHandler(impl);
+  starpc::Error err = mux->Register(handler.get());
+  if (err != starpc::Error::OK) {
+    return {nullptr, err};
+  }
+  return {std::move(handler), starpc::Error::OK};
+}
+
+} // namespace e2e::mock

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.43.1",
+  "version": "0.45.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -76,6 +76,7 @@
     "gen:force": "bun run go:aptre -- generate --force && bun run format",
     "test": "bun run test:js && bun run test:go",
     "test:go": "bun run go:aptre -- test",
+    "test:cpp": "mkdir -p build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release && cmake --build . --parallel && ctest --output-on-failure",
     "build:e2e": "bun run build && cd e2e && esbuild e2e.ts --sourcemap --outfile=e2e.cjs --bundle --platform=node",
     "test:js": "vitest run",
     "test:js:watch": "vitest",
@@ -107,19 +108,19 @@
     "esbuild": "^0.27.0",
     "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.0.2",
-    "happy-dom": "^20.4.0",
+    "happy-dom": "^20.5.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
     "prettier": "^3.8.1",
     "rimraf": "^6.1.2",
     "tsx": "^4.20.4",
     "typescript": "^5.8.2",
-    "@typescript/native-preview": "^7.0.0-dev.20260130.1",
+    "@typescript/native-preview": "^7.0.0-dev.20260202.1",
     "vitest": "^4.0.18"
   },
   "dependencies": {
     "@aptre/it-ws": "^1.1.2",
-    "@aptre/protobuf-es-lite": "^0.5.2",
+    "@aptre/protobuf-es-lite": "^0.5.3",
     "@chainsafe/libp2p-yamux": "^7.0.1",
     "@libp2p/interface": "^2.6.1",
     "event-iterator": "^2.0.0",
@@ -132,6 +133,6 @@
     "ws": "^8.18.1"
   },
   "resolutions": {
-    "@aptre/protobuf-es-lite": "0.5.2"
+    "@aptre/protobuf-es-lite": "0.5.3"
   }
 }

package/srpc/CMakeLists.txt

@@ -0,0 +1,59 @@
+cmake_minimum_required(VERSION 3.14)
+
+# C++ starpc library
+# This builds the core srpc library
+
+set(STARPC_SOURCES
+    packet.cpp
+    common-rpc.cpp
+    client-rpc.cpp
+    server-rpc.cpp
+    mux.cpp
+    client.cpp
+    rpcproto.pb.cc
+)
+
+set(STARPC_HEADERS
+    starpc.hpp
+    errors.hpp
+    message.hpp
+    writer.hpp
+    packet.hpp
+    stream.hpp
+    msg-stream.hpp
+    common-rpc.hpp
+    client-rpc.hpp
+    server-rpc.hpp
+    invoker.hpp
+    handler.hpp
+    mux.hpp
+    client.hpp
+    rpcproto.pb.h
+)
+
+add_library(starpc ${STARPC_SOURCES})
+
+target_include_directories(starpc PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/..
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_compile_features(starpc PUBLIC cxx_std_17)
+
+# Link protobuf
+find_package(Protobuf REQUIRED)
+target_link_libraries(starpc PUBLIC protobuf::libprotobuf)
+
+# Link threads
+find_package(Threads REQUIRED)
+target_link_libraries(starpc PUBLIC Threads::Threads)
+
+# Install targets
+install(TARGETS starpc
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib
+)
+
+install(FILES ${STARPC_HEADERS}
+    DESTINATION include/srpc
+)

package/srpc/client-rpc.cpp

@@ -0,0 +1,106 @@
+// go:build deps_only
+
+#include "client-rpc.hpp"
+
+#include "rpcproto.pb.h"
+
+namespace starpc {
+
+ClientRPC::ClientRPC(const std::string &service, const std::string &method) {
+  Init();
+  service_ = service;
+  method_ = method;
+}
+
+ClientRPC::~ClientRPC() = default;
+
+Error ClientRPC::Start(PacketWriter *writer, bool write_first_msg,
+                       const std::string &first_msg) {
+  if (writer == nullptr) {
+    return Error::NilWriter;
+  }
+
+  if (IsCanceled()) {
+    Cancel();
+    writer->Close();
+    return Error::Canceled;
+  }
+
+  bool first_msg_empty = false;
+  Error err = Error::OK;
+
+  {
+    std::lock_guard<std::mutex> lock(mtx_);
+    writer_ = writer;
+
+    if (write_first_msg) {
+      first_msg_empty = first_msg.empty();
+    }
+
+    auto pkt =
+        NewCallStartPacket(service_, method_, first_msg, first_msg_empty);
+    err = writer->WritePacket(*pkt);
+    if (err != Error::OK) {
+      Cancel();
+      writer->Close();
+    }
+  }
+
+  cv_.notify_all();
+  return err;
+}
+
+Error ClientRPC::HandlePacketData(const std::string &data) {
+  srpc::Packet pkt;
+  if (!pkt.ParseFromString(data)) {
+    return Error::InvalidMessage;
+  }
+  return HandlePacket(pkt);
+}
+
+void ClientRPC::HandleStreamClose(Error close_err) {
+  std::lock_guard<std::mutex> lock(mtx_);
+  if (close_err != Error::OK && remote_err_ == Error::OK) {
+    remote_err_ = close_err;
+  }
+  data_closed_ = true;
+  Cancel();
+  cv_.notify_all();
+}
+
+Error ClientRPC::HandlePacket(const srpc::Packet &msg) {
+  Error err = ValidatePacket(msg);
+  if (err != Error::OK) {
+    return err;
+  }
+
+  switch (msg.body_case()) {
+  case srpc::Packet::kCallStart:
+    return HandleCallStart(msg.call_start());
+  case srpc::Packet::kCallData:
+    return HandleCallData(msg.call_data());
+  case srpc::Packet::kCallCancel:
+    if (msg.call_cancel()) {
+      return HandleCallCancel();
+    }
+    return Error::OK;
+  default:
+    return Error::OK;
+  }
+}
+
+Error ClientRPC::HandleCallStart(const srpc::CallStart &pkt) {
+  // server-to-client calls not supported
+  return Error::UnrecognizedPacket;
+}
+
+void ClientRPC::Close() {
+  std::lock_guard<std::mutex> lock(mtx_);
+  // call did not start yet if writer is nil.
+  if (writer_ != nullptr) {
+    WriteCallCancelLocked();
+    CloseLocked();
+  }
+}
+
+} // namespace starpc

package/srpc/client-rpc.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <string>
+
+#include "common-rpc.hpp"
+#include "errors.hpp"
+#include "msg-stream.hpp"
+#include "packet.hpp"
+#include "writer.hpp"
+
+namespace srpc {
+class Packet;
+class CallStart;
+} // namespace srpc
+
+namespace starpc {
+
+// ClientRPC represents the client side of an on-going RPC call message stream.
+// Matches Go ClientRPC struct in client-rpc.go
+class ClientRPC : public CommonRPC, public MsgStreamRw {
+public:
+  // Constructor matching NewClientRPC in Go
+  ClientRPC(const std::string &service, const std::string &method);
+  ~ClientRPC() override;
+
+  // Start sets the writer and writes the CallStart message.
+  // Must only be called once!
+  // Matches Go Start method in client-rpc.go
+  Error Start(PacketWriter *writer, bool write_first_msg,
+              const std::string &first_msg);
+
+  // HandlePacketData handles an incoming unparsed message packet.
+  // Matches Go HandlePacketData in client-rpc.go
+  Error HandlePacketData(const std::string &data);
+
+  // HandleStreamClose handles the stream closing optionally with an error.
+  // Matches Go HandleStreamClose (overrides CommonRPC)
+  void HandleStreamClose(Error close_err);
+
+  // HandlePacket handles an incoming parsed message packet.
+  // Matches Go HandlePacket in client-rpc.go
+  Error HandlePacket(const srpc::Packet &pkt);
+
+  // HandleCallStart handles the call start packet.
+  // Matches Go HandleCallStart in client-rpc.go
+  Error HandleCallStart(const srpc::CallStart &pkt);
+
+  // Close releases any resources held by the ClientRPC.
+  // Matches Go Close in client-rpc.go
+  void Close();
+
+  // MsgStreamRw interface implementation
+  Error ReadOne(std::string *out) override { return CommonRPC::ReadOne(out); }
+  Error WriteCallData(const std::string &data, bool data_is_zero, bool complete,
+                      Error err) override {
+    return CommonRPC::WriteCallData(data, data_is_zero, complete, err);
+  }
+  Error WriteCallCancel() override { return CommonRPC::WriteCallCancel(); }
+};
+
+// NewClientRPC constructs a new ClientRPC session.
+// Matches Go NewClientRPC function in client-rpc.go
+inline std::unique_ptr<ClientRPC> NewClientRPC(const std::string &service,
+                                               const std::string &method) {
+  return std::make_unique<ClientRPC>(service, method);
+}
+
+} // namespace starpc

package/srpc/client.cpp

@@ -0,0 +1,101 @@
+// go:build deps_only
+
+#include "client.hpp"
+
+namespace starpc {
+
+Error ClientImpl::ExecCall(const std::string &service,
+                           const std::string &method, const Message &in,
+                           Message *out) {
+  std::string first_msg;
+  if (!in.SerializeToString(&first_msg)) {
+    return Error::InvalidMessage;
+  }
+
+  auto client_rpc = NewClientRPC(service, method);
+
+  // Open the stream with handlers
+  auto [writer, err] = open_stream_(
+      [&client_rpc](const std::string &data) -> Error {
+        return client_rpc->HandlePacketData(data);
+      },
+      [&client_rpc](Error close_err) {
+        client_rpc->HandleStreamClose(close_err);
+      });
+
+  if (err != Error::OK) {
+    return err;
+  }
+
+  err = client_rpc->Start(writer.get(), true, first_msg);
+  if (err != Error::OK) {
+    client_rpc->Close();
+    return err;
+  }
+
+  std::string msg;
+  err = client_rpc->ReadOne(&msg);
+  if (err != Error::OK) {
+    client_rpc->Close();
+    return err;
+  }
+
+  if (!out->ParseFromString(msg)) {
+    client_rpc->Close();
+    return Error::InvalidMessage;
+  }
+
+  client_rpc->Close();
+  return Error::OK;
+}
+
+std::pair<std::unique_ptr<Stream>, Error>
+ClientImpl::NewStream(const std::string &service, const std::string &method,
+                      const Message *first_msg) {
+  std::string first_msg_data;
+  if (first_msg != nullptr) {
+    if (!first_msg->SerializeToString(&first_msg_data)) {
+      return {nullptr, Error::InvalidMessage};
+    }
+  }
+
+  auto client_rpc = std::make_shared<ClientRPC>(service, method);
+
+  // Open the stream with handlers
+  auto [writer, err] = open_stream_(
+      [client_rpc](const std::string &data) -> Error {
+        return client_rpc->HandlePacketData(data);
+      },
+      [client_rpc](Error close_err) {
+        client_rpc->HandleStreamClose(close_err);
+      });
+
+  if (err != Error::OK) {
+    return {nullptr, err};
+  }
+
+  err = client_rpc->Start(writer.get(), first_msg != nullptr, first_msg_data);
+  if (err != Error::OK) {
+    return {nullptr, err};
+  }
+
+  // Create MsgStream with close callback
+  // Note: We need to capture writer to extend its lifetime
+  auto writer_ptr = writer.release();
+  auto stream =
+      std::make_unique<MsgStream>(client_rpc.get(), [client_rpc, writer_ptr]() {
+        client_rpc->Cancel();
+        if (writer_ptr) {
+          writer_ptr->Close();
+          delete writer_ptr;
+        }
+      });
+
+  // We need to keep client_rpc alive - in a real implementation
+  // we'd use a mechanism to tie its lifetime to the stream.
+  // For now, the shared_ptr in the lambda captures keeps it alive.
+
+  return {std::move(stream), Error::OK};
+}
+
+} // namespace starpc

package/srpc/client.hpp

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "client-rpc.hpp"
+#include "errors.hpp"
+#include "message.hpp"
+#include "msg-stream.hpp"
+#include "packet.hpp"
+#include "stream.hpp"
+#include "writer.hpp"
+
+namespace starpc {
+
+// OpenStreamFunc opens a stream with a remote.
+// msgHandler must not be called concurrently.
+// Matches Go OpenStreamFunc in client.go
+using OpenStreamFunc =
+    std::function<std::pair<std::unique_ptr<PacketWriter>, Error>(
+        PacketDataHandler msg_handler, CloseHandler close_handler)>;
+
+// Client implements a SRPC client which can initiate RPC streams.
+// Matches Go Client interface in client.go
+class Client {
+public:
+  virtual ~Client() = default;
+
+  // ExecCall executes a request/reply RPC with the remote.
+  virtual Error ExecCall(const std::string &service, const std::string &method,
+                         const Message &in, Message *out) = 0;
+
+  // NewStream starts a streaming RPC with the remote & returns the stream.
+  // firstMsg is optional (can be nullptr).
+  virtual std::pair<std::unique_ptr<Stream>, Error>
+  NewStream(const std::string &service, const std::string &method,
+            const Message *first_msg) = 0;
+};
+
+// ClientImpl is the default implementation of Client with a transport.
+// Matches Go client struct in client.go
+class ClientImpl : public Client {
+public:
+  explicit ClientImpl(OpenStreamFunc open_stream)
+      : open_stream_(std::move(open_stream)) {}
+
+  Error ExecCall(const std::string &service, const std::string &method,
+                 const Message &in, Message *out) override;
+
+  std::pair<std::unique_ptr<Stream>, Error>
+  NewStream(const std::string &service, const std::string &method,
+            const Message *first_msg) override;
+
+private:
+  OpenStreamFunc open_stream_;
+};
+
+// NewClient constructs a client with a OpenStreamFunc.
+// Matches Go NewClient function in client.go
+inline std::unique_ptr<Client> NewClient(OpenStreamFunc open_stream) {
+  return std::make_unique<ClientImpl>(std::move(open_stream));
+}
+
+} // namespace starpc