#jaredzhou/pony

#Installation

moon add jaredzhou/pony        # latest
moon add jaredzhou/pony@0.3.0  # pin version

#Quick Start

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

  // GET /hello  => 200 "Hello, world!"
  r.add(HttpMethod::Get, "/hello", ctx => {
    ctx.write_text(status_ok, "Hello, world!")
  })

  // GET /greet/pony  => 200 "Hello, pony!"
  r.add(HttpMethod::Get, "/greet/{name}", ctx => {
    let name = ctx.try_param("name").unwrap_or("stranger")
    ctx.write_text(status_ok, "Hello, \(name)!")
  })

  start("127.0.0.1:3000", r)
}

#Features

#Router

let r = Router::Router()

// Static route — exact path match
r.add(HttpMethod::Get, "/ping", pong_handler)

// Path parameter {param} — matches a single segment
r.add(HttpMethod::Get, "/users/{id}", user_handler)

// Wildcard * — matches everything after the prefix
r.add(HttpMethod::Get, "/static/*", static_handler)

// Multiple parameters in one pattern
r.add(HttpMethod::Get, "/users/{userId}/posts/{postId}", post_handler)

// Match all HTTP methods
r.any("/health", health_handler)

// Route-specific middleware (applied before the handler)
r.add(
  HttpMethod::Get,
  "/admin",
  mws=[admin_auth],
  admin_handler,
)

// Sub-router mounting — all routes under /api/v1
let api = Router::Router()
api.add(HttpMethod::Get, "/status", status_handler)
r.mount("/api/v1", api)

// Custom 404 / 405 handlers
r.set_not_found(ctx => {
  ctx.reply_error(ApiError::not_found("page not found"))
})
r.set_method_not_allowed(ctx => {
  ctx.write_json(status_method_not_allowed, { "error": "method not allowed" })
})

#Server

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

#Request Context

///|
let id : Int = ctx.param("id") catch {
  e => {
    ctx.reply_error(e)
    return
  }
}

///|
let token : String = ctx.header("Authorization") catch {
  e => {
    ctx.reply_error(e)
    return
  }
}

///|
let page : Int = ctx.query("page") catch { _ => 1 }

///|
struct UserId(Int)

///|
pub impl @pony.FromStr for UserId with fn from_str(s) {
  UserId(@pony.FromStr::from_str(s))
}

///|
let uid : UserId = ctx.param("id") catch { ... }

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

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

///|
let name = ctx.try_form("name").unwrap_or("")

///|
struct LoginReq {
  username : String
  password : String
} derive(FromJson)

///|
let req : LoginReq = ctx.json() catch {
  _ => {
    ctx.reply_error(ApiError::invalid_argument("invalid JSON body"))
    return
  }
}

ctx.set_content_type("application/json")
ctx.write_text(status_ok, "Hello")
ctx.write_json(status_ok, {"key": "value"})
ctx.reply_ok({"status": "ok"})                                  // 200 JSON
ctx.reply_error(ApiError::invalid_argument("bad input"))        // 400 JSON
ctx.reply_error(ApiError::not_found("not found"))               // 404 JSON
ctx.reply_error(ApiError::permission_denied("not allowed"))     // 403 JSON
ctx.redirect("/login")                                             // 302
ctx.no_content()                                                   // 204

#Extension Store

///|
// 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 {
  ctx => {
    match ctx.try_header("X-User-Id") {
      Some(user_id) => ctx.set_ext(UserId{}, user_id)
      None => {
        ctx.reply_error(ApiError::unauthenticated("missing X-User-Id header"))
        return
      }
    }
    next(ctx)
  }
}

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

  r.add(HttpMethod::Get, "/me", ctx => {
    let user_id : String = ctx.get_ext(UserId{}) catch {
      e => {
        ctx.reply_error(e)
        return
      }
    }
    ctx.reply_ok({ "user_id": user_id })
  })

  start("127.0.0.1:3000", r)
}

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

let uid = ctx.get_ext(@pony.UserId{}) catch {
  e => {
    ctx.reply_error(e)
    return
  }
}

#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)))

#Error handling

///|
pub suberror PonyError {
  MissingParam(String)
  MissingQuery(String)
  MissingForm(String)
  MissingHeader(String)
  MissingExt(String)
  ExtDecodeError(String, String)
  MissingFormFile(String)
  InvalidValue(String, String)
}

ctx.reply_error(ApiError::invalid_argument("invalid id"))
ctx.reply_error(ApiError::not_found("list not found"))
ctx.reply_error(ApiError::permission_denied("access denied"))

///|
pub impl @pony.ToApiError for MyError with fn to_api_error(self : MyError) -> @pony.ApiError {
  match self {
    MyError::NotFound(m) => @pony.ApiError::not_found(m)
    MyError::Forbidden(m) => @pony.ApiError::permission_denied(m)
  }
}

// Now you can pass MyError directly:
ctx.reply_error(my_error)

#File Upload

///|
r.add(HttpMethod::Post, "/upload", async ctx => {
  // Parse the multipart body (call once per request)
  ctx.parse_multipart_form()!

  // Read regular form fields
  let title : String = ctx.form("title") catch {
    e => { ctx.reply_error(e); return }
  }

  // Access uploaded files
  let file = ctx.form_file("avatar") catch {
    e => { ctx.reply_error(e); return }
  }

  // File metadata available immediately
  println("received: \{file.filename} (\{file.size} bytes, \{file.content_type})")

  // Read file content (async)
  let data = file.bytes()

  ctx.reply_ok({
    "title": title,
    "filename": file.filename,
    "size": file.size,
  })
})

#License