#gaato/mttp_async

#Install

moon add gaato/mttp_async

#Call an API

///|
pub async fn show_user() -> Unit {
  let api = @mttp_async.client(base_url="https://api.example.com")
  defer api.close()
  let user = @mttp_async.get("/users/1").response(@mttp_async.as_json_value())
  match api.send(user).body {
    Ok(json) => println(json.stringify())
    Err(failure) => println(failure)
  }
}

///|
fn main {
  @mttp_async.run(show_user)
}

///|
/// Fetches a user and prints it, the status that stopped it, or the network
/// failure.
pub async fn print_user(id : Int32) -> Unit {
  let api = @mttp_async.client(base_url="https://api.example.com")
  defer api.close()
  let reply = api.send(
    @mttp_async.get("/users/\{id}").response(@mttp_async.as_json_value()),
  ) catch {
    error => {
      println("network: \{error}")
      return
    }
  }
  match reply.body {
    Ok(user) => println(user.stringify())
    Err(failure) => println("HTTP: \{failure}")
  }
}

#What client() does by default

#Cookies

///|
/// Logs in, then reads a page that needs the session cookie.
pub async fn account_page(token : String) -> String? {
  let jar = @mttp_async.CookieJar::new(@mttp_async.clock())
  let site = @mttp_async.client(base_url="https://shop.example", cookies=jar)
  defer site.close()
  ignore(site.send(@mttp_async.post("/login").body_json({ "token": token })))
  site.send(@mttp_async.get("/account")).body.to_option()
}

#With an API SDK

///|
let claude = @anthropic.Anthropic::new(
  api_key~,
  @mttp_async.backend(),
  @mttp_async.clock(),
  timer=@mttp_async.timer(),
)

#Serve

@server.serve(request => @mttp_async.Response::new(200), addr="127.0.0.1:8080")

///|
/// Echoes a request body of up to 64 KiB; a larger one gets 413.
pub async fn echo(
  request : @mttp_async.Request,
) -> @mttp_async.Response noraise {
  let body = request.body.read_all(max=65536) catch {
    TransportError(kind=TooLarge(..), ..) =>
      return @mttp_async.Response::new(413)
    _ => return @mttp_async.Response::new(400)
  }
  @mttp_async.Response::new(200, body=Bytes(body))
}

#A complete app

import {
  "gaato/mttp_async",
  "gaato/mttp_async/server",
  "gaato/mttp/endpoint",
  "gaato/mttp/router",
  "gaato/mttp/schema",
}

pkgtype(kind: "executable")

///|
/// GET /hello/{name} answers with a greeting.
let hello : @endpoint.ServerEndpoint = @endpoint.endpoint
  .get("/hello/{name}")
  .input(@endpoint.path("name", @schema.string))
  .output(@endpoint.text_out())
  .serve_public(name => Ok("hello, \{name}"))

///|
let app : @router.Router = @router.Router::must([hello])

///|
pub async fn serve_app(addr : String) -> Unit {
  @server.serve(app.handler(), addr~, on_listen=bound => println(bound))
}

///|
fn main {
  @mttp_async.run(async fn() { serve_app("127.0.0.1:8080") })
}

#Tests

///|
/// Reads a user's name; the Client is a parameter, so a test can pass a stub.
pub async fn user_name(api : @mttp_async.Client, id : Int32) -> String? {
  let user = @mttp_async.get("/users/\{id}").response(
    @mttp_async.as_json_value(),
  )
  match api.send(user).body {
    Ok({ "name": String(name), .. }) => Some(name)
    _ => None
  }
}

///|
test "user_name reads the name from the reply" {
  let stub = @testing.BackendStub::new().when(
    request => request.url == "https://api.example/users/1",
    @testing.Canned::bytes(200, body=b"{\"name\":\"Ada\"}"),
  )
  let api = @mttp_async.client(base_url="https://api.example", backend=stub)
  let name : Ref[String?] = Ref(None)
  @mttp_async.run(async fn() { name.val = user_name(api, 1) })
  assert_eq(name.val, Some("Ada"))
  assert_eq(stub.sent().length(), 1)
}

#Targets

#Packages

#License