spaceship_helm - v0.1.0

spaceship_helm

Types

App

</> 
pub type App {
  App(
    get: List(types.Route),
    post: List(types.Route),
    put: List(types.Route),
    delete: List(types.Route),
    patch: List(types.Route),
    head: List(types.Route),
    options: List(types.Route),
    custom: dict.Dict(String, List(types.Route)),
    not_found: fn(types.Context) -> response.Response(BitArray),
    middleware: List(
      fn(
        types.Context,
        fn(types.Context) -> response.Response(BitArray),
      ) -> response.Response(BitArray),
    ),
    async_get: List(types.AsyncRoute),
    async_post: List(types.AsyncRoute),
    async_put: List(types.AsyncRoute),
    async_delete: List(types.AsyncRoute),
    async_patch: List(types.AsyncRoute),
    async_head: List(types.AsyncRoute),
    async_options: List(types.AsyncRoute),
    async_custom: dict.Dict(String, List(types.AsyncRoute)),
    async_not_found: fn(types.Context) -> promise.Promise(
      response.Response(BitArray),
    ),
    async_middleware: List(
      fn(
        types.Context,
        fn(types.Context) -> promise.Promise(
          response.Response(BitArray),
        ),
      ) -> promise.Promise(response.Response(BitArray)),
    ),
    extra: dict.Dict(String, dynamic.Dynamic),
  )
}

Constructors

Values

async_delete

</> 
pub fn async_delete(
  app: App,
  path: String,
  handler: fn(types.Context) -> promise.Promise(
    response.Response(BitArray),
  ),
) -> App

Register an asynchronous DELETE route.

async_get

</> 
pub fn async_get(
  app: App,
  path: String,
  handler: fn(types.Context) -> promise.Promise(
    response.Response(BitArray),
  ),
) -> App

Register an asynchronous GET route.

async_middleware

</> 
pub fn async_middleware(
  app: App,
  mw: fn(
    types.Context,
    fn(types.Context) -> promise.Promise(
      response.Response(BitArray),
    ),
  ) -> promise.Promise(response.Response(BitArray)),
) -> App

Add asynchronous middleware.

async_not_found

</> 
pub fn async_not_found(
  app: App,
  handler: fn(types.Context) -> promise.Promise(
    response.Response(BitArray),
  ),
) -> App

Set the asynchronous not-found handler.

async_on

</> 
pub fn async_on(
  app: App,
  method: String,
  path: String,
  handler: fn(types.Context) -> promise.Promise(
    response.Response(BitArray),
  ),
) -> App

Register an asynchronous route with a custom method.

async_post

</> 
pub fn async_post(
  app: App,
  path: String,
  handler: fn(types.Context) -> promise.Promise(
    response.Response(BitArray),
  ),
) -> App

Register an asynchronous POST route.

async_put

</> 
pub fn async_put(
  app: App,
  path: String,
  handler: fn(types.Context) -> promise.Promise(
    response.Response(BitArray),
  ),
) -> App

Register an asynchronous PUT route.

delete

</> 
pub fn delete(
  app: App,
  path: String,
  handler: fn(types.Context) -> response.Response(BitArray),
) -> App

Register a DELETE route

get

</> 
pub fn get(
  app: App,
  path: String,
  handler: fn(types.Context) -> response.Response(BitArray),
) -> App

Register a GET route

group

</> 
pub fn group(
  app: App,
  prefix: String,
  routes: fn(App) -> App,
) -> App

Group routes under a prefix

</> 
pub fn head(
  app: App,
  path: String,
  handler: fn(types.Context) -> response.Response(BitArray),
) -> App

Register a HEAD route

middleware

</> 
pub fn middleware(
  app: App,
  mw: fn(
    types.Context,
    fn(types.Context) -> response.Response(BitArray),
  ) -> response.Response(BitArray),
) -> App

Add global middleware

new

</> 
pub fn new() -> App

Create a new app

not_found

</> 
pub fn not_found(
  app: App,
  handler: fn(types.Context) -> response.Response(BitArray),
) -> App

Set custom not-found handler

on

</> 
pub fn on(
  app: App,
  method: String,
  path: String,
  handler: fn(types.Context) -> response.Response(BitArray),
) -> App

Register a route with custom method

options

</> 
pub fn options(
  app: App,
  path: String,
  handler: fn(types.Context) -> response.Response(BitArray),
) -> App

Register an OPTIONS route

patch

</> 
pub fn patch(
  app: App,
  path: String,
  handler: fn(types.Context) -> response.Response(BitArray),
) -> App

Register a PATCH route

post

</> 
pub fn post(
  app: App,
  path: String,
  handler: fn(types.Context) -> response.Response(BitArray),
) -> App

Register a POST route

put

</> 
pub fn put(
  app: App,
  path: String,
  handler: fn(types.Context) -> response.Response(BitArray),
) -> App

Register a PUT route

to_fetch

</> 
pub fn to_fetch(
  app: App,
) -> fn(request.Request(BitArray)) -> response.Response(BitArray)

Convert app to a fetch handler for JS runtimes

to_fetch_async

</> 
pub fn to_fetch_async(
  app: App,
) -> fn(request.Request(BitArray)) -> promise.Promise(
  response.Response(BitArray),
)

Convert an app with asynchronous routes to a Fetch-style handler.

with

</> 
pub fn with(app: App, key: String, value: dynamic.Dynamic) -> App

Add extra data to app context (e.g., env for Cloudflare Workers)

✨ Search Document