🥮 mooncakes.io

mocket

A web framework for MoonBit.

http
server
moon add oboard/mocket@0.7.8
Download zip
Author
Version
0.7.8
License
Apache-2.0
Repository
Last updated
3 hours ago
Downloads
2K

Dependencies

README

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

#
HttpHandler

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

#
Middleware

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

#
MiddlewareNext

source
type MiddlewareNext = async () -> &Responder noraise

#
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 {
  fn get_meta(Self, id : StringView) -> StaticAssetMeta?
  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
}

#
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
  headers : Map[StringView, 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

#
HttpResponse

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

#
HttpResponse::body

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

fn HttpResponse::delete_cookie(self : HttpResponse, key : String) -> Unit

#
HttpResponse::json

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

#
HttpResponse::new

source
fn HttpResponse::new(status_code : StatusCode, headers? : Map[StringView, 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 noraise]
  middlewares : Array[(String, async (MocketEvent, async () -> &Responder noraise) -> &Responder noraise)]
  static_routes : Map[String, Map[String, async (MocketEvent) -> &Responder noraise]]
  dynamic_routes : Map[String, Array[(String, async (MocketEvent) -> &Responder noraise)]]
  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]
  // private fields
}

#
Mocket::acl

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

#
Mocket::all

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

#
Mocket::bind

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

#
Mocket::checkin

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

#
Mocket::checkout

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

#
Mocket::connect

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

#
Mocket::copy

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

#
Mocket::delete

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

#
Mocket::get

source
fn Mocket::get(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder noraise) -> 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 noraise) -> Unit

#
Mocket::label

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

fn Mocket::link(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder noraise) -> 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 noraise) -> Unit

#
Mocket::merge

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

#
Mocket::mkactivity

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

#
Mocket::mkcalendar

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

#
Mocket::mkcol

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

#
Mocket::mkredirectref

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

#
Mocket::mkworkspace

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

#
Mocket::move_

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

#
Mocket::on

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

#
Mocket::options

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

#
Mocket::orderpatch

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

#
Mocket::patch

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

#
Mocket::post

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

#
Mocket::pri

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

#
Mocket::propfind

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

#
Mocket::proppatch

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

#
Mocket::put

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

#
Mocket::query

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

#
Mocket::rebind

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

#
Mocket::report

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

#
Mocket::search

source
fn Mocket::search(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder noraise) -> 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 noraise) -> Unit

#
Mocket::unbind

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

#
Mocket::uncheckout

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

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

#
Mocket::unlock

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

#
Mocket::update

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

#
Mocket::updateredirectref

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

#
Mocket::use_middleware

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

#
Mocket::version_control

source
fn Mocket::version_control(self : Mocket, path : String, handler : async (MocketEvent) -> &Responder noraise) -> 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[StringView, StringView], raw_body : Bytes) -> HttpResponse noraise

#
escape_html

source
fn escape_html(s : String) -> String

#
execute_middlewares

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

#
form_encode

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

#
handle_not_found

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

#
html

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

#
listen_ffi

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

#
new

source
fn new(base_path? : String) -> 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]

#
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