|
ActiveConnection<'T>
|
Represents an active connection being processed
|
|
Authentication
|
|
|
Aux
|
|
|
BinaryFormatterSerialiser
|
Default JSON-based cookie serializer.
NOTE: this implementation serializes `Map` polymorphically using
the reflection-based `System.Text.Json` APIs. It is therefore NOT compatible
with .NET Native AOT or aggressive trimming. Consumers targeting AOT must
implement `CookieSerialiser` themselves over a closed payload schema (e.g.
using a `JsonSerializerContext` source generator) and assign it to
`SuaveConfig.cookieSerialiser`.
The historical name `BinaryFormatterSerialiser` is preserved for source
compatibility; the underlying engine has been `System.Text.Json` for a while.
|
|
ByteConstants
|
|
|
Compression
|
|
|
ConnectionFacade
|
|
|
ConnectionHealth
|
|
|
ConnectionHealthChecker
|
Module for monitoring and managing connection health
|
|
Control
|
|
|
Cookie
|
The cookie module is geared towards the server having the client store state
but the client not being able to read that state.
|
|
CookieSerialiser
|
|
|
CORS
|
|
|
DotLiquid
|
A module for rendering DotLiquid template with Suave
|
|
Embedded
|
|
|
EventSource
|
A module that implements the Server-Sent Event specification, which can be
read at www.w3.org/TR/eventsource.
|
|
Files
|
The files module can be used to serve from the file system. It encapsulates
common patterns like verifying that back-symlinks or keywords aren't used
to gain access outside the intended folder.
|
|
Filters
|
Module that deals with the applicatives of suave - use functions from this module
to filter what requests a given route responds to.
Functions have signature f :: params... -> HttpContext -> HttpContext option.
|
|
Globals
|
|
|
Headers
|
|
|
Hpack
|
HPACK compression format (largely coppied from Haskell's HTTP2 package)
|
|
Http
|
|
|
Http2
|
|
|
HttpOutput
|
|
|
HttpReader
|
|
|
Intermediate
|
Control-flow functions, such as 100 Continue and 101 Switching Protocol.
|
|
Json
|
|
|
Model
|
|
|
Operators
|
|
|
Proxy
|
|
|
RateLimit
|
Rate limiting module for Suave web server
|
|
Redirection
|
Functions have signature f :: params... -> HttpContext -> Async<unit> option
Multiple items
type Async =
static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool>
static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload
static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool>
static member CancelDefaultToken: unit -> unit
static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>>
static member Choice: computations: Async<'T option> seq -> Async<'T option>
static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads
static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
...
--------------------
type Async<'T>
type unit = Unit
type 'T option = Option<'T>
.
Functions from here are 'end routes' in that they don't require you to keep
returning applicatives, but can end up in an async monad/workflow that writes
the data to the client in the end.
This class of status code indicates that further action needs to be
taken by the user agent in order to fulfill the request. The action
required MAY be carried out by the user agent without interaction
with the user if and only if the method used in the second request is
GET or HEAD. A client SHOULD detect infinite redirection loops, since
such loops generate network traffic for each redirection.
|
|
RequestErrors
|
10.4 Client Error 4xx The 4xx class of status code is intended for cases in which the
client seems to have erred. Except when responding to a HEAD request,
the server SHOULD include an entity containing an explanation of the
error situation, and whether it is a temporary or permanent
condition. These status codes are applicable to any request method.
User agents SHOULD display any included entity to the user.
If the client is sending data, a server implementation using TCP
SHOULD be careful to ensure that the client acknowledges receipt of
the packet(s) containing the response, before the server closes the
input connection. If the client continues sending data to the server
after the close, the server's TCP stack will send a reset packet to
the client, which may erase the client's unacknowledged input buffers
before they can be read and interpreted by the HTTP application.
|
|
Response
|
The HTTP module has these main sub-modules:
- Response - response and response_f functions.
- Writers - ways to modify the response.
- Intermediate - 100 and 101 response codes.
- Successful- 2xx response codes.
- Redirection - 3xx response codes.
- RequestErrors - 4xx response codes.
- ServerErrors - 5xx response codes.
- Applicatives - use to filter down the request to something you want
- Files - send files to the client
- Authentication - Methods for authenticating http requests
and these main types: - WebResult = Async option
- WebPart = HttpContext -> WebResult
- HttpMethod
|
|
Router
|
Module for efficient HTTP routing with path parameter support
|
|
Runtime
|
|
|
ScanResult
|
|
|
SecurityHeaders
|
Security Headers module for comprehensive HTTP security header management
|
|
SelectFunction
|
|
|
SelectResult
|
|
|
ServerErrors
|
10.5 Server Error 5xx
Response status codes beginning with the digit "5" indicate cases in
which the server is aware that it has erred or is incapable of
performing the request. Except when responding to a HEAD request, the
server SHOULD include an entity containing an explanation of the
error situation, and whether it is a temporary or permanent
condition. User agents SHOULD display any included entity to the
user. These response codes are applicable to any request method.
|
|
Sscanf
|
|
|
State
|
|
|
Stream
|
|
|
SuaveConfig (Module)
|
|
|
SuaveConfig (Type)
|
The core configuration of suave. See also Suave.Web.default_config which
you can use to bootstrap the configuration:
{ default_config with bindings = [ ... ] }
|
|
Successful
|
2xx successful responses
Functions have signature f :: params... -> HttpContext -> Async<unit> option
Multiple items
type Async =
static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool>
static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload
static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool>
static member CancelDefaultToken: unit -> unit
static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>>
static member Choice: computations: Async<'T option> seq -> Async<'T option>
static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads
static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
...
--------------------
type Async<'T>
type unit = Unit
type 'T option = Option<'T>
.
Functions from here are 'end routes' in that they don't require you to keep
returning applicatives, but can end up in an async monad/workflow that writes
the data to the client in the end.
|
|
Tcp
|
|
|
TcpServerFactory
|
|
|
TransferEncoding
|
|
|
Validation
|
Input Validation Framework for Suave
|
|
ValidationWebParts
|
WebPart helpers for input validation
|
|
Web
|
|
|
WebPart
|
|
|
WebSocket
|
|
|
Writers
|
Module that allows changing the output response in different ways.
Functions have signature f :: params... -> HttpContext -> HttpContext.
|