Skip to content

# REPE to JSON-RPC Conversion

Utilities to convert between REPE messages with JSON bodies and JSON-RPC 2.0 messages, enabling interoperability between the REPE and JSON-RPC protocols.

## Quick Start

    #include "glaze/rpc/repe/repe_to_jsonrpc.hpp"

    // REPE → JSON-RPC
    repe::message msg{};
    msg.query = "/add";
    msg.body = R"([1,2,3])";
    msg.header.id = 42;
    msg.header.body_format = repe::body_format::JSON;

    std::string jsonrpc = repe::to_jsonrpc_request(msg);
    // {"jsonrpc":"2.0","method":"add","params":[1,2,3],"id":42}

## API Reference

### Converting REPE to JSON-RPC

#### Request Conversion

Function: `std::string to_jsonrpc_request(const message& msg)`

Converts a REPE request message to a JSON-RPC request string.

    #include "glaze/rpc/repe/repe_to_jsonrpc.hpp"

    repe::message msg{};
    msg.query = "/add";                          // Method name (with or without leading slash)
    msg.body = R"([1,2,3])";                     // JSON parameters
    msg.header.id = 42;                          // Request ID
    msg.header.body_format = repe::body_format::JSON;  // Must be JSON format
    msg.header.notify = false;                   // false for request, true for notification

    std::string jsonrpc_request = repe::to_jsonrpc_request(msg);
    // Result: {"jsonrpc":"2.0","method":"add","params":[1,2,3],"id":42}

#### Response Conversion

Function: `std::string to_jsonrpc_response(const message& msg)`

Converts a REPE response message to a JSON-RPC response string.

    // Success response
    repe::message success_msg{};
    success_msg.body = R"({"result":"success"})";
    success_msg.header.id = 42;
    success_msg.header.body_format = repe::body_format::JSON;
    success_msg.header.ec = glz::error_code::none;

    std::string jsonrpc_response = repe::to_jsonrpc_response(success_msg);
    // Result: {"jsonrpc":"2.0","result":{"result":"success"},"id":42}

    // Error response
    repe::message error_msg{};
    error_msg.body = "Method not found";
    error_msg.header.id = 42;
    error_msg.header.body_format = repe::body_format::UTF8;
    error_msg.header.ec = glz::error_code::method_not_found;

    std::string jsonrpc_error = repe::to_jsonrpc_response(error_msg);
    // Result: {"jsonrpc":"2.0","error":{"code":-32601,"message":"Method not found","data":"Method not found"},"id":42}

### Converting JSON-RPC to REPE

#### Request Conversion

Function: `expected<message, std::string> from_jsonrpc_request(std::string_view json_request)`

Converts a JSON-RPC request string to a REPE message.

    std::string jsonrpc = R"({"jsonrpc":"2.0","method":"add","params":[1,2,3],"id":42})";

    auto msg = repe::from_jsonrpc_request(jsonrpc);
    if (msg.has_value()) {
        // msg->query == "/add"
        // msg->body == "[1,2,3]"
        // msg->header.id == 42
        // msg->header.body_format == repe::body_format::JSON
    }

#### Response Conversion

Function: `expected<message, std::string> from_jsonrpc_response(std::string_view json_response)`

Converts a JSON-RPC response string to a REPE message.

    // Success response
    std::string jsonrpc_success = R"({"jsonrpc":"2.0","result":{"value":42},"id":10})";

    auto success = repe::from_jsonrpc_response(jsonrpc_success);
    if (success.has_value()) {
        // success->header.id == 10
        // success->header.ec == glz::error_code::none
        // success->body contains {"value":42}
    }

    // Error response
    std::string jsonrpc_error = R"({"jsonrpc":"2.0","error":{"code":-32601,"message":"Method not found","data":"Details"},"id":42})";

    auto error = repe::from_jsonrpc_response(jsonrpc_error);
    if (error.has_value()) {
        // error->header.id == 42
        // error->header.ec == glz::error_code::method_not_found
        // error->body == "Details"
    }

### Error Code Mapping

REPE Error | JSON-RPC Error | Code
--- | --- | ---
`error_code::none` | `error_e::no_error` | 0
`error_code::parse_error` | `error_e::parse_error` | -32700
`error_code::syntax_error` | `error_e::parse_error` | -32700
`error_code::invalid_header` | `error_e::invalid_request` | -32600
`error_code::version_mismatch` | `error_e::invalid_request` | -32600
`error_code::method_not_found` | `error_e::method_not_found` | -32601
Other errors | `error_e::internal` | -32603

### Notifications

REPE notifications (messages with `notify = true`) are converted to JSON-RPC notifications (requests with `id = null`):

    repe::message notification{};
    notification.query = "/notify";
    notification.body = R"({"message":"hello"})";
    notification.header.notify = true;

    std::string jsonrpc = repe::to_jsonrpc_request(notification);
    // Result: {"jsonrpc":"2.0","method":"notify","params":{"message":"hello"},"id":null}

### ID Handling

REPE uses `uint64_t` for IDs, while JSON-RPC supports strings, numbers, or null:

- Numeric IDs are directly mapped between protocols
- Numeric strings (e.g., `"123"`) are parsed as numbers
- Non-numeric strings are hashed to create a REPE ID

    // Numeric string ID
    std::string jsonrpc = R"({"jsonrpc":"2.0","method":"test","params":[],"id":"999"})";
    auto msg = repe::from_jsonrpc_request(jsonrpc);
    // msg->header.id == 999

    // Non-numeric string ID
    std::string jsonrpc2 = R"({"jsonrpc":"2.0","method":"test","params":[],"id":"test-123"})";
    auto msg2 = repe::from_jsonrpc_request(jsonrpc2);
    // msg2->header.id == hash("test-123")

### Requirements

- REPE message body must be in JSON format for conversion to JSON-RPC requests
- REPE message body should be in JSON or UTF8 format for conversion to JSON-RPC responses
- The query field in REPE requests is treated as the method name (leading slash is optional)

### Bridging Protocols Example

    #include "glaze/rpc/repe/repe_to_jsonrpc.hpp"

    // Receive JSON-RPC request from client
    std::string jsonrpc_request = R"({"jsonrpc":"2.0","method":"add","params":[1,2,3],"id":42})";

    // Convert to REPE
    auto repe_request = repe::from_jsonrpc_request(jsonrpc_request);

    if (repe_request.has_value()) {
        // Process with REPE server
        repe::message repe_response = process(repe_request.value());

        // Convert response back to JSON-RPC
        std::string jsonrpc_response = repe::to_jsonrpc_response(repe_response);
    }