#jaredzhou/pony

#Installation

moon add jaredzhou/pony

#Quick Start

///|
fn main {
  let r = Router::Router()

  // GET /ping => 200 "pong"
  r.add(HttpMethod::Get, "/ping", fn(ctx) { ctx.write_text(status_ok, "pong") })

  // GET /users/{id}  => 200 "user: 42"
  // ctx.param raises PonyError if missing — use try_param for Option
  r.add(HttpMethod::Get, "/users/{id}", fn(ctx) {
    let id = ctx.try_param("id").unwrap_or("")
    ctx.write_text(status_ok, "user: \(id)")
  })

  // GET /search?q=pony  => 200 "searching: pony"
  r.add(HttpMethod::Get, "/search", fn(ctx) {
    let q = ctx.try_query("q").unwrap_or("")
    ctx.write_text(status_ok, "searching: \(q)")
  })

  // GET /api/status  => 200 {"status":"ok"}
  r.add(HttpMethod::Get, "/api/status", fn(ctx) {
    ctx.reply_ok({ "status": "ok" })
  })

  // POST /api/items — standard error pattern with to_api_error
  r.add(HttpMethod::Post, "/api/items", async fn(ctx) {
    let req : ItemReq = ctx.json() catch {
      e => {
        ctx.reply_error(to_api_error(PonyError::InvalidArgument(e.to_string())))
        return
      }
    }
    ctx.reply_ok({ "created": true })
  })

  // GET /static/css/app.css  => 200 "file: css/app.css"
  r.add(HttpMethod::Get, "/static/*", fn(ctx) {
    let path = ctx.try_wildcard().unwrap_or("")
    ctx.write_text(status_ok, "file: \(path)")
  })

  start("127.0.0.1:3000", r)
}

#Features

#Router

• Radix tree with priority matching for static, parameter, and wildcard routes
• {param} path parameters and * wildcard capture
• Route-specific middleware per endpoint
• Sub-router mounting with mount()
• Custom 404 and 405 handlers

#Middleware

r.use_mw(@mw.logger())
r.use_mw(@mw.cors(
  allow_origins=["*"],
  allow_methods=["GET", "POST"],
))
r.use_mw(@mw.jwt(new_hmac_sha256(secret)))

#Auth

///|
// Marker type — an empty struct used as a type-safe key
struct UserId {}

///|
// Middleware: extract user_id from header and store in context
fn auth_middleware(next : Handler) -> Handler {
  fn(ctx) {
    match ctx.try_header("X-User-Id") {
      Some(user_id) => ctx.set_ext(UserId{}, user_id)
      None => {
        ctx.reply_error(ApiError::new(unauthenticated, "missing X-User-Id header"))
        return
      }
    }
    next(ctx)
  }
}

///|
fn main {
  let r = Router::Router()
  r.use_mw(auth_middleware)

  // Handler reads user_id from ext store — raises PonyError::MissingExt if not set
  r.add(HttpMethod::Get, "/me", fn(ctx) {
    let user_id : String = ctx.get_ext(UserId{}) catch {
      e => {
        ctx.reply_error(to_api_error(e))
        return
      }
    }
    ctx.reply_ok({ "user_id": user_id })
  })

  start("127.0.0.1:3000", r)
}

#Request Context (Context)

///|
let user = ctx.header("X-User") catch {
  e => {
    ctx.reply_error(to_api_error(e))
    return
  }
}

///|
let q = ctx.try_query("search").unwrap_or("")

///|
let page = ctx.try_query("page").unwrap_or("1")

ctx.set_content_type("application/json")
ctx.write_text(200, "Hello")
ctx.write_json(200, {"key": "value"})
ctx.reply_ok({"status": "ok"})                              // 200 JSON
ctx.reply_error(to_api_error(PonyError::InvalidArgument("bad input"))) // error JSON
ctx.reply_error(ApiError::new(invalid_argument, "bad input"))          // direct ApiError
ctx.redirect("/login")                                         // 302 redirect
ctx.no_content()                                               // 204

#Error handling

///|
pub suberror PonyError {
  MissingParam(String)
  MissingQuery(String)
  MissingForm(String)
  MissingHeader(String)
  MissingExt(String)
  ExtDecodeError(String, String)
  MissingFormFile(String)
  InvalidArgument(String) // generic 400
  NotFound(String) // generic 404
  PermissionDenied(String) // generic 403
}

ctx.reply_error(to_api_error(PonyError::InvalidArgument("invalid id")))
ctx.reply_error(to_api_error(PonyError::NotFound("list not found")))

///|
let req : MyBody = ctx.json() catch {
  e => {
    ctx.reply_error(to_api_error(PonyError::InvalidArgument(e.to_string())))
    return
  }
}

#Extension Store

ctx.set_ext(@pony.RequestId{}, "req-abc")
ctx.set_ext(@pony.UserId{}, "user-42")

let uid = ctx.get_ext(@pony.UserId{})

#Header

let h = @pony.new()
h.set("Content-Type", "application/json")
h.add("Set-Cookie", "session=abc")
let ct = h.get("Content-Type")  // "application/json"

#Server

let server = @pony.Server::new("127.0.0.1:3000", router)
  .with_timeout(read=5000, write=10000)
server.start()!

#License