🥮 mooncakes.io

mocket

A web framework for MoonBit.

http
server
Download zip
Author
Version
0.9.1
License
Apache-2.0
Repository
Last updated
7 days ago
Downloads
2K

Dependencies

#oboard/mocket

Version GitHub Workflow Status (with event) License

A web framework for MoonBit.

👉 Documentation

#Quick Start

async fn main {
  let app = @mocket.new()
  app.get("/", _ => "Hello, Mocket!")
  app.listen(":80")
}

Mocket supports both js and native backends.

#JavaScript Backend

Set the backend of MoonBit to js in Visual Studio Code

Command: MoonBit: Select Backend -> js

moon run src/example --target js

#Native Backend

Set the backend of MoonBit to native in Visual Studio Code

Command: MoonBit: Select Backend -> native

moon run src/example --target native

Then visit http://localhost:4000

#Usage

Minimum Example: https://github.com/oboard/mocket_example

🙌快来吧！🙌

QQ 群号：949886784

QQ 群

ErrorHandler

source
type ErrorHandler = (MocketEvent, Error) -> &Responder

HttpHandler

source
type HttpHandler = async (MocketEvent) -> &Responder

Middleware

source
type Middleware = async (MocketEvent, async () -> &Responder) -> &Responder

MiddlewareNext

source
type MiddlewareNext = async () -> &Responder

WebSocketHandler

source
type WebSocketHandler = (WebSocketEvent) -> Unit

BodyReader

source
pub(open) trait BodyReader {
  fn from_request(req : HttpRequest) -> Self raise
}

impl BodyReader for Bytes
impl BodyReader for Json

Responder

source
pub(open) trait Responder {
  fn options(Self, res : HttpResponse) -> Unit
  fn output(Self, buf : 
Buffer) -> Unit
}

impl Responder for String
impl Responder for Bytes
impl Responder for Json
impl Responder for ToJson

ServeStaticProvider

source
pub(open) trait ServeStaticProvider {
  async fn get_meta(Self, id : StringView) -> StaticAssetMeta?
  async fn get_contents(Self, id : StringView) -> &Responder
  fn get_type(Self, ext : String) -> String?
  fn get_encodings(Self) -> Map[String, String]
  fn get_index_names(Self) -> Array[String]
  fn get_fallthrough(Self) -> Bool
}

A backend for Mocket::static_assets.

Asset ids handed to the provider are virtual absolute paths rooted at the mount point: they always start with "/" and are already normalized, so "." / ".." segments can never escape the provider's root. Providers should join the id onto their root directly.

ExecError

source
pub suberror ExecError

IOError

source
pub suberror IOError

NetworkError

source
pub suberror NetworkError

CookieItem

source
pub(all) struct CookieItem {
  name : String
  value : String
  max_age : Int?
  path : String?
  domain : String?
  secure : Bool?
  http_only : Bool?
  same_site : SameSiteOption?
} derive(Eq)

impl Show for CookieItem

Html

source
type Html

impl Responder for Html

HttpRequest

source
pub(all) struct HttpRequest {
  http_method : String
  url : String
  query : String
  headers : Map[
CaseInsensitiveString, StringView]
  raw_body : Bytes
}

HttpRequest::body

source
fn[T : BodyReader] HttpRequest::body(self : HttpRequest) -> T raise

fn HttpRequest::get_cookie(self : HttpRequest, name : String) -> CookieItem?

HttpRequest::json

source

HttpRequest::query

source
fn HttpRequest::query(self : HttpRequest) -> Map[String, String]

HttpResponse

source
pub(all) struct HttpResponse {
  status_code : StatusCode
  headers : Map[
CaseInsensitiveString, StringView]
  cookies : Map[String, CookieItem]
  raw_body : Bytes
}

HttpResponse::body

source
fn HttpResponse::body(self : HttpResponse, body : &Responder) -> HttpResponse

Sets the response body from any Responder.

The body responder's default Content-Type is carried into this response only when no explicit "Content-Type" header was set on this response. Explicit response headers always take precedence.

Only the default Content-Type is inferred. The responder's status, other headers, cookies, and any other responder effects are not merged, so self.status_code is preserved.
fn HttpResponse::delete_cookie(self : HttpResponse, key : String) -> Unit

HttpResponse::json

source
fn HttpResponse::json(self : HttpResponse, obj : &ToJson) -> HttpResponse

Sets a JSON response body.

Infers Content-Type: application/json; charset=utf-8 under the same rule as HttpResponse::body: an explicit "Content-Type" header already present on this response takes precedence, and self.status_code is preserved.

HttpResponse::new

source
fn HttpResponse::new(status_code : StatusCode, headers? : Map[
CaseInsensitiveString, StringView], cookies? : Map[String, CookieItem], raw_body? : Bytes) -> HttpResponse

HttpResponse::read_body

source
fn[T : BodyReader] HttpResponse::read_body(self : HttpResponse) -> T raise

fn HttpResponse::set_cookie(self : HttpResponse, name : String, value : String, max_age? : Int, path? : String, domain? : String, secure? : Bool, http_only? : Bool, same_site? : SameSiteOption) -> Unit

HttpResponse::to_responder

source
fn HttpResponse::to_responder(self : HttpResponse) -> &Responder

Mocket

source
#alias(T)
pub(all) struct Mocket {
  base_path : String
  mappings : Map[(String, String), async (MocketEvent) -> &Responder]
  middlewares : Array[(String, async (MocketEvent, async () -> &Responder) -> &Responder)]
  static_routes : Map[String, Map[String, async (MocketEvent) -> &Responder]]
  dynamic_routes : Map[String, Array[(String, async (MocketEvent) -> &Responder)]]
  ws_static_routes : Map[String, (WebSocketEvent) -> Unit]
  ws_dynamic_routes : Array[(String, (WebSocketEvent) -> Unit)]
  ws_clients : Map[String, Unit]
  ws_channels : Map[String, Map[String, Unit]]
  ws_client_port : Map[String, Int]
  max_body_size : Int
  error_handler : (MocketEvent, Error) -> &Responder
  // private fields
}

Mocket::acl

source
fn Mocket::acl(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::all

source
fn Mocket::all(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::bind

source
fn Mocket::bind(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::checkin

source
fn Mocket::checkin(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::checkout

source
fn Mocket::checkout(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::connect

source
fn Mocket::connect(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::copy

source
fn Mocket::copy(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::delete

source
fn Mocket::delete(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::get

source
fn Mocket::get(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::group

source
fn Mocket::group(self : Mocket, base_path : String, configure : (Mocket) -> Unit) -> Unit

Mocket::head

source
fn Mocket::head(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::label

source
fn Mocket::label(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

fn Mocket::link(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::listen

source
async fn Mocket::listen(self : Mocket, address : String) -> Unit noraise

Mocket::lock

source
fn Mocket::lock(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::merge

source
fn Mocket::merge(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::mkactivity

source
fn Mocket::mkactivity(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::mkcalendar

source
fn Mocket::mkcalendar(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::mkcol

source
fn Mocket::mkcol(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::mkredirectref

source
fn Mocket::mkredirectref(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::mkworkspace

source
fn Mocket::mkworkspace(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::move_

source
fn Mocket::move_(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::on

source
fn Mocket::on(self : Mocket, event : String, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::on_error

source
fn Mocket::on_error(self : Mocket, handler : (MocketEvent, Error) -> &Responder) -> Unit

Mocket::options

source
fn Mocket::options(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::orderpatch

source
fn Mocket::orderpatch(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::patch

source
fn Mocket::patch(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::post

source
fn Mocket::post(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::pri

source
fn Mocket::pri(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::propfind

source
fn Mocket::propfind(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::proppatch

source
fn Mocket::proppatch(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::put

source
fn Mocket::put(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::query

source
fn Mocket::query(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::rebind

source
fn Mocket::rebind(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::report

source
fn Mocket::report(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::search

source
fn Mocket::search(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::serve

source
#deprecated("use `Mocket::listen(address)` instead")
async fn Mocket::serve(self : Mocket, port~ : Int) -> Unit noraise

Mocket::static_assets

source
fn Mocket::static_assets(self : Mocket, path : String, provider : &ServeStaticProvider) -> Unit

Mocket::trace

source
fn Mocket::trace(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::unbind

source
fn Mocket::unbind(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::uncheckout

source
fn Mocket::uncheckout(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

fn Mocket::unlink(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::unlock

source
fn Mocket::unlock(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::update

source
fn Mocket::update(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::updateredirectref

source
fn Mocket::updateredirectref(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::use_middleware

source
fn Mocket::use_middleware(self : Mocket, middleware : async (MocketEvent, async () -> &Responder) -> &Responder, base_path? : String) -> Unit

Mocket::version_control

source
fn Mocket::version_control(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder) -> Unit

Mocket::ws

source
fn Mocket::ws(self : Mocket, path : String, handler : (WebSocketEvent) -> Unit) -> Unit

MocketEvent

source
pub(all) struct MocketEvent {
  req : HttpRequest
  res : HttpResponse
  params : Map[String, StringView]
}

MultipartFormValue

source
pub(all) struct MultipartFormValue {
  filename : String?
  content_type : String?
  data : BytesView
}

SameSiteOption

source
pub(all) enum SameSiteOption {
  Lax
  Strict
  SameSiteNone
} derive(Eq)

StaticAssetMeta

source
pub(all) struct StaticAssetMeta {
  asset_type : String?
  etag : String?
  mtime : Int64?
  path : String?
  size : Int64?
  encoding : String?
}

StaticAssetMeta::new

source
fn StaticAssetMeta::new(asset_type? : String, etag? : String, mtime? : Int64, path? : String, size? : Int64, encoding? : String) -> StaticAssetMeta

StatusCode

source
pub(all) enum StatusCode {
  Continue
  SwitchingProtocols
  Processing
  EarlyHints
  OK
  Created
  Accepted
  NonAuthoritativeInfo
  NoContent
  ResetContent
  PartialContent
  MultiStatus
  AlreadyReported
  IMUsed
  MultipleChoices
  MovedPermanently
  Found
  SeeOther
  NotModified
  UseProxy
  TemporaryRedirect
  PermanentRedirect
  BadRequest
  Unauthorized
  PaymentRequired
  Forbidden
  NotFound
  MethodNotAllowed
  NotAcceptable
  ProxyAuthRequired
  RequestTimeout
  Conflict
  Gone
  LengthRequired
  PreconditionFailed
  RequestEntityTooLarge
  RequestUriTooLong
  UnsupportedMediaType
  RequestedRangeNotSatisfiable
  ExpectationFailed
  Teapot
  MisdirectedRequest
  UnprocessableEntity
  Locked
  FailedDependency
  TooEarly
  UpgradeRequired
  PreconditionRequired
  TooManyRequests
  RequestHeaderFieldsTooLarge
  UnavailableForLegalReasons
  InternalServerError
  NotImplemented
  BadGateway
  ServiceUnavailable
  GatewayTimeout
  HttpVersionNotSupported
  VariantAlsoNegotiates
  InsufficientStorage
  LoopDetected
  NotExtended
  NetworkAuthenticationRequired
  Custom(Int)
} derive(Eq, ToJson)

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

StatusCode::from_int

source
fn StatusCode::from_int(i : Int) -> StatusCode

StatusCode::to_int

source
fn StatusCode::to_int(self : StatusCode) -> Int

WebSocketAggregatedMessage

source
pub(all) enum WebSocketAggregatedMessage {
  Text(String)
  Binary(Bytes)
  Ping
}

WebSocketEvent

source
pub(all) enum WebSocketEvent {
  Open(WebSocketPeer)
  Message(WebSocketPeer, WebSocketAggregatedMessage)
  Close(WebSocketPeer)
}

WebSocketPeer

source
pub(all) struct WebSocketPeer {
  connection_id : String
  subscribed_channels : Array[String]
}

WebSocketPeer::binary

source
fn WebSocketPeer::binary(self : WebSocketPeer, message : Bytes) -> Unit

WebSocketPeer::pong

source
fn WebSocketPeer::pong(self : WebSocketPeer) -> Unit

WebSocketPeer::publish

source
fn WebSocketPeer::publish(channel : String, message : String) -> Unit

WebSocketPeer::subscribe

source
fn WebSocketPeer::subscribe(self : WebSocketPeer, channel : String) -> Unit

WebSocketPeer::text

source
fn WebSocketPeer::text(self : WebSocketPeer, message : String) -> Unit

WebSocketPeer::to_string

source
fn WebSocketPeer::to_string(self : WebSocketPeer) -> String

WebSocketPeer::unsubscribe

source
fn WebSocketPeer::unsubscribe(self : WebSocketPeer, channel : String) -> Unit

__ws_emit

source
fn __ws_emit(event_type : Bytes, connection_id : Bytes, payload : Bytes) -> Unit

fn cookie_to_string(cookie : Array[CookieItem]) -> String

dispatch_http

source
async fn dispatch_http(mocket : Mocket, http_method : String, url : String, headers : Map[
CaseInsensitiveString, StringView], raw_body : Bytes) -> HttpResponse

dispatch_ws_event

source
fn dispatch_ws_event(handler : (WebSocketEvent) -> Unit, peer : WebSocketPeer, event_type : String, payload : Bytes) -> Unit

将 WS 事件类型字符串和 payload 转换为 WebSocketEvent 并调用 handler

encode_multipart

source
fn encode_multipart(m : Map[String, MultipartFormValue], boundary : String) -> String

escape_html

source
fn escape_html(s : String) -> String

execute_middlewares

source
async fn execute_middlewares(middlewares : Array[(String, async (MocketEvent, async () -> &Responder) -> &Responder)], event : MocketEvent, final_handler : async (MocketEvent) -> &Responder) -> &Responder

form_encode

source
fn form_encode(map : Map[String, String]) -> String

handle_not_found

source
fn handle_not_found() -> (async (MocketEvent) -> &Responder)

html

source
fn html(html : &Show) -> &Responder

listen_ffi

source
async fn listen_ffi(mocket : Mocket, address : String) -> Unit noraise

Listen and serve on address.

The native listener enables SO_REUSEADDR (reuse_addr=true) so that a process can immediately rebind a port that a previous process left in TIME_WAIT. On macOS/BSD this has the side effect that a bind to a specific address may "steal" the specific interface from an existing wildcard bind (0.0.0.0), and a wildcard bind can bind to the remaining interfaces if a specific-interface bind already exists.

new

source
fn new(base_path? : String, max_body_size? : Int) -> Mocket

fn parse_cookie(cookie : StringView) -> Map[String, CookieItem]

parse_form_data

source
fn parse_form_data(bytes : BytesView) -> Map[String, String]

parse_multipart

source
fn parse_multipart(bytes : BytesView, boundary : String) -> Map[String, MultipartFormValue]

parse_query

source
fn parse_query(query_string : StringView) -> Map[String, String]

register_ws_connection

source
fn register_ws_connection(connection_id : String, text_sender : (String) -> Unit, binary_sender : (Bytes) -> Unit, pong_sender : () -> Unit) -> Unit

register_ws_handler

source
fn register_ws_handler(mocket : Mocket, port : Int) -> Unit

serve_ffi

source
async fn serve_ffi(mocket : Mocket, port~ : Int) -> Unit noraise

suspend

source
async fn[T, E : Error] suspend(f : ((T) -> Unit, (E) -> Unit) -> Unit) -> T raise E

suspend 会中断当前协程的运行。 suspend 会接受一个回调函数，并让这个回调函数来操作中断的协程

text

source
fn text(text : &Show) -> &Responder

unregister_ws_connection

source
fn unregister_ws_connection(connection_id : String) -> Unit

url_decode

source
fn url_decode(bytes : BytesView) -> String

url_encode

source
fn url_encode(s : String) -> String

ws_pong

source
fn ws_pong(id : String) -> Unit

ws_publish

source
fn ws_publish(channel : String, msg : String) -> Unit

ws_send

source
fn ws_send(id : String, msg : String) -> Unit

ws_send_bytes

source
fn ws_send_bytes(id : String, msg : Bytes) -> Unit

ws_subscribe

source
fn ws_subscribe(id : String, channel : String) -> Unit

ws_unsubscribe

source
fn ws_unsubscribe(id : String, channel : String) -> Unit

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io