JSON RPC

JSON RPC Call

Defined in call.v, the module provides two JSON RPC functions to call JSON RPC Methods. These act as wrappers functions that handle decoding encoding and errors for method calls to the function provided in the call parameters.

To perform calls to methods that don't take any parameters, json2.Null must be passed as the generic parameter for the function parameter

As with all JSONRPC functionalities, calls with multiple parameters aren't supported in these call functions. Function call parameters must be scaffolded into a single struct

Notifications

A JSON-RPC call that does not require any response data, or where the client does not expect any result (other than possibly an acknowledgement of receipt), is typically referred to as a "notification". In JSON-RPC 2.0, a notification is characterized by the absence of an "id" field in the request. This signals to the server that no response is expected. (chatgpt 4.0)

Handler

Handler Generation

Defined in handler_gen.v, handler generation allows for JSON RPC Handlers to be generated for a provided set of RPC Methods.

handler_gen_test.v

In the handler generation test, a handler is generated for a Tester struct which has methods with various parameters and return types. This tests ensures that the handle method generated for the Handler can exhaustively generate method call matchers for functions with varying return and parameter types.

fn call[T, D](msg string, method fn (T) !D) !string

performs jsonrpc call on provided method

fn call_void[T](msg string, method fn (T) !) !string

performs jsonrpc call on provided method that doesnt return anything returns ok or error, unlike notify which does not return anything

fn decode_request[T](data string) !JsonRpcRequest[T]

fn decode_request_id(data string) !string

fn decode_request_method(data string) !string

fn decode_response[D](data string) !Response[D]

fn generate_client(config GenerateClientConfig) Module

fn generate_client_factory(name string) !CodeFile

generate_client_factory generates a factory code file with factory functions for the client

fn generate_client_method(client_struct Struct, method Function) !Function

fn generate_client_methods(client_struct Struct, methods []Function) ![]Function

fn generate_client_struct(name string) Struct

fn generate_handler(args HandlerArgs) ![]codemodel.CodeItem

fn generate_ws_factory_code(name_ string) ![]CodeItem

fn invoke[D](msg string, method fn () !D) !string

performs jsonrpc call on provided method without parameters

fn jsonrpcerror_decode(data string) !JsonRpcError

pub fn decode_response[D](data string) !JsonRpcResponse[D] { raw := json2.raw_decode(data)! if 'error' in raw.as_map() { return json.decode(JsonRpcError, data)! } return json.decode(JsonRpcResponse[D], data)! }

fn jsonrpcrequest_decode[T](data string) !JsonRpcRequest[T]

fn jsonrpcrequest_decode_any(data string) !JsonRpcRequestAny

fn jsonrpcrequest_decode_method(data string) !string

fn jsonrpcresponse_decode[D](data string) !JsonRpcResponse[D]

fn new_error(id string, error InnerJsonRpcError) JsonRpcError

fn new_handler(logger &log.Logger) !&JsonRpcHandler

fn new_jsonrpcerror(id string, error InnerJsonRpcError) JsonRpcError

fn new_jsonrpcrequest[T](method string, params T) JsonRpcRequest[T]

fn new_jsonrpcresponse[T](id string, result T) JsonRpcResponse[T]

fn new_response[T](id string, result T) JsonRpcResponse[T]

fn notify[T](params_json string, method fn (T) !)

fn request_decode_any(data string) !JsonRpcRequestAny

fn request_params(data string) !string

returns json encoded params field of request

interface IJsonRpcClient {
mut:
	transport IRpcTransportClient
}

JSON-RPC WebSoocket Server

fn (mut client IJsonRpcClient) send_json_rpc[T, D](method string, data T, timeout int) !D

interface IRpcTransportClient {
mut:
	send(string, int) !string
}

fn (j &JsonRpcRequest[T]) to_json() string

fn (j &JsonRpcResponse[D]) to_json() string

struct ClientConfig {
	address string // address of ws server
	logger  &log.Logger
}

struct GenerateClientConfig {
	name    string
	methods []Function
}

struct HandlerArgs {
pub:
	stateful bool
	receiver Struct
	methods  []codemodel.Function
}

struct InnerJsonRpcError {
pub mut:
	code    int    @[required]
	message string @[required]
	data    string
}

fn (err InnerJsonRpcError) code() int

fn (err InnerJsonRpcError) msg() string

struct JsonRpcError {
pub mut:
	jsonrpc string            @[required]
	error   InnerJsonRpcError @[required]
	id      string            @[required]
}

fn (j &JsonRpcError) to_json() string

struct JsonRpcHandler {
pub mut:
	// rpcwebsocket.RpcWsServer // server for ws communication
	logger &log.Logger
	// map of method names to procedure handlers
	procedures map[string]ProcedureHandler
	state      voidptr
}

JSON-RPC WebSoocket Server

fn (mut server JsonRpcHandler) register(name string, procedure ProcedureHandler) !

registers procedure handlers by method name

fn (mut handler JsonRpcHandler) handler(client &websocket.Client, message string) string

fn (mut handler JsonRpcHandler) handle(message string) !string

struct JsonRpcRequest[T] {
pub mut:
	jsonrpc string @[required]
	method  string @[required]
	params  T      @[required]
	id      string @[required]
}

struct JsonRpcRequestAny {
pub mut:
	jsonrpc string @[required]
	method  string @[required]
	id      string @[required]
}

struct JsonRpcResponse[D] {
pub mut:
	jsonrpc string @[required]
	result  D
	id      string @[required]
}