🥮 mooncakes.io
    Sign in

    jsonrpc2

    MoonBit jsonrpc2: provide simple JSON-RPC 2.0 abstractions.

    json
    json-rpc2
    rpc2
    Download zip
    Author
    Version
    0.0.7
    License
    Apache-2.0
    Repository
    Last updated
    last year
    Downloads
    161

    #gmlewis/jsonrpc2

    check

    This is a simple abstraction for the JSON-RPC 2.0 specification: https://www.jsonrpc.org/specification based on the Go implementation: https://pkg.go.dev/golang.org/x/exp/jsonrpc2 which has copyright:
    // Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

    #Status

    The code has been updated to support compiler:

    $ moon version --all
moon 0.1.20250513 (5aa200a 2025-05-13) ~/.moon/bin/moon
moonc v0.1.20250514+8798a70d6 ~/.moon/bin/moonc
moonrun 0.1.20250513 (5aa200a 2025-05-13) ~/.moon/bin/moonrun

    Framer

    source
    pub trait Framer {
      reader(Self, 
    ByteReader    ) -> Reader
      writer(Self, 
    Writer    ) -> Writer
    }

    Framer wraps low level byte readers and writers into jsonrpc2 message readers and writers. It is responsible for the framing and encoding of messages into wire form.

    Reader

    source
    pub trait Reader {
      read(Self) -> (Message?, Int64, 
    IOError    ?)
    }

    Reader abstracts the transport mechanics from the JSON RPC protocol. A Conn reads messages from the reader it was provided on construction, and assumes that each call to Read fully transfers a single message, or returns an error. A reader is not safe for concurrent use, it is expected it will be used by a single Conn in a safe manner.

    Writer

    source
    pub trait Writer {
      write(Self, Message) -> (Int64, 
    IOError    ?)
    }

    Writer abstracts the transport mechanics from the JSON RPC protocol. A Conn writes messages using the writer it was provided on construction, and assumes that each call to Write fully transfers a single message, or returns an error. A writer is not safe for concurrent use, it is expected it will be used by a single Conn in a safe manner.

    HeaderFramer

    source
    pub struct HeaderFramer {
    }

    HeaderReader

    source
    pub struct HeaderReader {
      in_ : 
    ByteReader
    }

    HeaderWriter

    source
    pub struct HeaderWriter {
      out : 
    Writer
    }

    pub enum ID {
      Number(Int64)
      String(String)
    }

    ID is used to identify the request and tie it to the response.
    impl Eq for ID
    impl Show for ID
    impl ToJson for ID
    impl FromJson for ID

    ID::number

    source
    fn ID::number(n : Int64) -> ID

    ID::string

    source
    fn ID::string(s : String) -> ID

    LineFramer

    source
    pub struct LineFramer {
    }

    LineReader

    source
    pub struct LineReader {
      in_ : 
    ByteReader
    }

    LineWriter

    source
    pub struct LineWriter {
      out : 
    Writer
    }

    Message

    source
    pub enum Message {
      Request(Request)
      Response(Response)
      BatchRequest(Array[Request])
      BatchResponse(Array[Response])
    }

    Message covers all jsonrpc2 message types. They share no common functionality, but are a closed set of concrete types that are allowed to implement this interface. The message types are Request and Response.
    impl Eq for Message
    impl Show for Message
    impl ToJson for Message
    impl FromJson for Message

    Message::as_batch_request

    source
    fn Message::as_batch_request(self : Message) -> Array[Request]?

    as_batch_request returns the message as a batch request if it is one.

    Message::as_batch_response

    source
    fn Message::as_batch_response(self : Message) -> Array[Response]?

    as_batch_response returns the message as a batch response if it is one.

    Message::as_call

    source
    fn Message::as_call(self : Message) -> Request?

    Message::as_notification

    source
    fn Message::as_notification(self : Message) -> Request?

    Message::as_request

    source
    fn Message::as_request(self : Message) -> Request?

    Message::as_response

    source
    fn Message::as_response(self : Message) -> Response?

    RawFramer

    source
    pub struct RawFramer {
    }

    RawReader

    source
    type RawReader

    impl Reader for RawReader

    RawWriter

    source
    type RawWriter

    impl Writer for RawWriter

    Request

    source
    pub(all) struct Request {
      id : ID?
      method_ : String
      params : Json
    }

    A Request is a message sent to a peer to request behavior. If it has an ID then it is a call and therefore requests a response, otherwise it is a notification which receives no response.
    impl Eq for Request
    impl Show for Request
    impl ToJson for Request
    impl FromJson for Request

    Response

    source
    pub(all) struct Response {
      id : ID
      result : Result[Json, WireError]
    }

    Response is a Message used as a reply to a call Request. It will have the same ID as the call it is a response to.
    impl Eq for Response
    impl Show for Response
    impl ToJson for Response

    WireError

    source
    pub(all) struct WireError {
      code : Int
      message : String
      data : Json?
    }

    WireError is a jsonrpc2 error message.
    impl Eq for WireError
    impl Show for WireError
    impl ToJson for WireError

    as_batch_request

    source
    fn as_batch_request(self : Message) -> Array[Request]?

    as_batch_request returns the message as a batch request if it is one.

    as_batch_response

    source
    fn as_batch_response(self : Message) -> Array[Response]?

    as_batch_response returns the message as a batch response if it is one.

    as_call

    source
    fn as_call(self : Message) -> Request?

    as_notification

    source
    fn as_notification(self : Message) -> Request?

    as_request

    source
    fn as_request(self : Message) -> Request?

    as_response

    source
    fn as_response(self : Message) -> Response?

    header_framer

    source
    fn header_framer() -> Framer

    header_framer returns a new Framer. The messages are sent with HTTP content length and MIME type headers. This is the format used by LSP and others.

    line_framer

    source
    fn line_framer() -> Framer

    line_framer returns a new Framer. The messages are sent with a terminating cr+newline, and rely on json decode consistency to determine message boundaries.

    new_batch_request

    source
    fn new_batch_request(messages : Array[Message]) -> Message

    new_batch_request constructs a new batch request message for the supplied requests.

    new_batch_response

    source
    fn new_batch_response(messages : Array[Message]) -> Message

    new_batch_response constructs a new batch response message for the supplied responses.

    new_call

    source
    fn new_call(id : ID, method_ : String, params : Json) -> Message

    new_call constructs a new call message for the supplied ID, method and parameters.

    new_notification

    source
    fn new_notification(method_ : String, params : Json) -> Message

    new_notification constructs a new notification message for the supplied method and parameters.

    new_response

    source
    fn new_response(id : ID, result : Result[Json, WireError]) -> Message

    new_response constructs a new Response message.

    raw_framer

    source
    fn raw_framer() -> Framer

    raw_framer returns a new Framer. The messages are sent with no wrapping, and rely on json decode consistency to determine message boundaries.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io