🥮 mooncakes.io

    http

    Sans-IO HTTP vocabulary for MoonBit SDKs: request/response types, a Transport trait, an incremental SSE parser and a scripted fake transport. No dependencies; runs on every backend.

    http
    sans-io
    transport
    sse
    client
    Download zip
    Author
    Version
    0.1.0
    License
    Apache-2.0
    Repository
    Last updated
    yesterday
    Downloads
    91

    #gaato/http

    Sans-IO HTTP vocabulary for MoonBit SDKs: Request, Response, Headers, the Transport and BodyStream traits, middleware, a Clock trait (gaato/http/clock), an incremental WHATWG-conformant SSE parser (gaato/http/sse), and a scripted FakeTransport / FakeClock for tests (gaato/http/mock). No dependencies; runs on wasm-gc, wasm, js and native.

    An SDK built on this module never imports an async runtime: the caller passes a Transport and a Clock, for example from gaato/http-async.

    Unofficial and experimental. Source, issues and design notes: https://github.com/gaato/mbt-sdk

    Middleware

    source
    type Middleware = async (Request, async (Request) -> Response raise HttpError) -> Response raise HttpError

    An async request wrapper receiving the next operation in the chain.

    BodyStream

    source
    pub(open) trait BodyStream {
      async fn read_some(Self) -> Bytes? raise HttpError
      fn close(Self) -> Unit
    }

    A readable response body. None signals end of stream.

    Transport

    source
    pub(open) trait Transport {
      async fn send(Self, Request) -> Response raise HttpError
      async fn send_stream(Self, Request) -> (ResponseHead, &BodyStream) raise HttpError
    }

    Sends requests without interpreting HTTP status codes as errors.

    HttpError

    source
    pub(all) suberror HttpError {
      Connect(String)
      Timeout(Int)
      Protocol(String)
    } derive(
    Debug    )

    Transport failures, separate from ordinary HTTP response statuses.

    HttpError::to_repr

    source

    Debug representation of a transport failure.

    Headers

    source
    pub struct Headers {
      // private fields
    } derive(Eq, 
    Debug    )

    Mutable, ordered header pairs with ASCII lowercase names. Equality compares normalized pairs, including their order.

    test {
      let headers = @http.Headers::from_array([("Accept", "text/plain")])
      assert_eq(headers.get("ACCEPT"), Some("text/plain"))
    }

    Headers::append

    source
    fn Headers::append(self : Headers, name : String, value : String) -> Unit

    Appends one pair, retaining all existing values.

    Headers::contains

    source
    fn Headers::contains(self : Headers, name : String) -> Bool

    Reports whether at least one value exists for a name.

    Headers::each

    source
    fn Headers::each(self : Headers, f : (String, String) -> Unit raise?) -> Unit raise?

    Visits a snapshot of normalized pairs in insertion order.

    Headers::equal

    source
    fn Headers::equal(Headers, Headers) -> Bool

    Explicit equality methods for normalized, ordered pairs.

    Headers::from_array

    source
    fn Headers::from_array(pairs : Array[(String, String)]) -> Headers

    Copies pairs in their original order and normalizes their names.

    Headers::get

    source
    fn Headers::get(self : Headers, name : String) -> String?

    Returns the first value for a name, ignoring ASCII case.

    Headers::get_all

    source
    fn Headers::get_all(self : Headers, name : String) -> Array[String]

    Returns a fresh array containing every matching value in insertion order.

    Headers::iter

    source
    fn Headers::iter(self : Headers) -> Iter[(String, String)]

    Iterates over a snapshot of normalized pairs in insertion order.

    Headers::length

    source
    fn Headers::length(self : Headers) -> Int

    Returns the number of pairs, counting repeated names separately.

    Headers::new

    source
    fn Headers::new() -> Headers

    Creates an empty header collection.

    Headers::not_equal

    source
    fn Headers::not_equal(x : Headers, y : Headers) -> Bool

    Explicit equality methods for normalized, ordered pairs.

    Headers::remove

    source
    fn Headers::remove(self : Headers, name : String) -> Unit

    Removes all pairs for a name, ignoring ASCII case.

    Headers::set

    source
    fn Headers::set(self : Headers, name : String, value : String) -> Unit

    Replaces all values for a name at its first position, or appends a new name.

    Headers::to_repr

    source

    Debug representation of the header pairs.

    Request

    source
    pub(all) struct Request {
      http_method : String
      url : String
      headers : Headers
      body : Bytes
    } derive(Eq, 
    Debug    )

    An HTTP request with a byte body. Builders copy headers before returning.

    test {
      let request = @http.Request::post("/items")
        .header("Accept", "application/json")
        .body_text("hello")
      assert_eq(request.body, b"hello")
    }

    Request::body_bytes

    source
    fn Request::body_bytes(self : Request, body : Bytes) -> Request

    Returns a new request with the supplied bytes and independent headers.

    Request::body_text

    source
    fn Request::body_text(self : Request, body : String) -> Request

    Returns a new request whose body is the UTF-8 encoding of the text.

    Request::delete

    source
    fn Request::delete(url : String) -> Request

    Creates a DELETE request.

    Request::equal

    source
    fn Request::equal(Request, Request) -> Bool

    Compares all request fields.

    Request::get

    source
    fn Request::get(url : String) -> Request

    Creates a GET request.

    Request::header

    source
    fn Request::header(self : Request, name : String, value : String) -> Request

    Returns a new request with an appended header and independent headers.

    Request::json_body

    source
    fn Request::json_body(self : Request, body : Json) -> Request

    Encodes JSON as UTF-8 and supplies application/json only if content-type is absent.

    Request::new

    source
    fn Request::new(http_method : String, url : String) -> Request

    Creates a request with the supplied method, empty headers and an empty body.

    Request::not_equal

    source
    fn Request::not_equal(x : Request, y : Request) -> Bool

    Compares all request fields.

    Request::patch

    source
    fn Request::patch(url : String) -> Request

    Creates a PATCH request.

    Request::post

    source
    fn Request::post(url : String) -> Request

    Creates a POST request.

    Request::put

    source
    fn Request::put(url : String) -> Request

    Creates a PUT request.

    Request::to_repr

    source

    Debug representation of a request.

    Response

    source
    pub(all) struct Response {
      status : Int
      headers : Headers
      body : Bytes
    } derive(Eq, 
    Debug    )

    An HTTP response. Error status codes are ordinary responses.

    test {
      let response : @http.Response = {
        status: 200,
        headers: @http.Headers::new(),
        body: b"hello",
      }
      assert_eq(response.text(), "hello")
      assert_true(response.is_success())
    }

    Response::equal

    source
    fn Response::equal(Response, Response) -> Bool

    Compares all response fields.

    Response::is_success

    source
    fn Response::is_success(self : Response) -> Bool

    Reports whether the status is in the inclusive range 200 through 299.

    Response::json

    source
    fn Response::json(self : Response) -> Json raise

    Parses the strictly decoded body, raising on malformed UTF-8 or invalid JSON.

    Response::not_equal

    source
    fn Response::not_equal(x : Response, y : Response) -> Bool

    Compares all response fields.

    Response::text

    source

    Strictly decodes the UTF-8 body, raising on malformed input.

    Response::to_repr

    source

    Debug representation of a response.

    ResponseHead

    source
    pub(all) struct ResponseHead {
      status : Int
      headers : Headers
    } derive(Eq, 
    Debug    )

    Status and headers available before consuming a streamed body.

    ResponseHead::equal

    source

    Compares status and headers.

    ResponseHead::not_equal

    source
    fn ResponseHead::not_equal(x : ResponseHead, y : ResponseHead) -> Bool

    Compares status and headers.

    ResponseHead::to_repr

    source

    Debug representation of a response head.

    send_with

    source
    async fn send_with(transport : &Transport, middleware : Array[async (Request, async (Request) -> Response raise HttpError) -> Response raise HttpError], request : Request) -> Response raise HttpError

    Sends through middleware in array order, with the first element outermost.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io