serverkit 0.4.1

A portable Rust HTTP application layer for Workers and native servers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#![forbid(unsafe_code)]
#![allow(async_fn_in_trait)]
#![doc = include_str!("../README.md")]

extern crate self as serverkit;

mod app;
mod body;
mod cookie;
mod error;
mod extract;
mod handler;
mod middleware;
mod multipart;
pub mod openapi;
mod redirect;
mod request;
mod response;
mod route;
mod router;
pub mod schemaval;
mod sse;
mod stream;
#[cfg(feature = "websocket")]
mod websocket;

pub use app::{Config, Router};

pub use body::Body;

pub use cookie::{Cookie, Cookies, SameSite};

pub use error::{Error, ErrorFormat};

pub use extract::{
    Bytes, ConnectInfo, Extension, Form, FormError, FromRequest, Header, HeaderError,
    MissingConnectInfo, MissingExtension, MissingState, Path, PathError, Query, QueryError, State,
    Text, TextError,
};

#[cfg(feature = "json")]
pub use extract::{Json, JsonError};

pub use handler::Handler;

pub use middleware::{Middleware, Next};

pub use multipart::{Multipart, MultipartError, MultipartField};

pub use openapi::{
    ApiKeyLocation, ExampleValue, OAuthFlow, OAuthFlows, OpenApi, OpenApiDocument, Operation,
    ParameterLocation, Scalar, ScalarDeveloperTools, SecurityRequirement, SecurityScheme, Server,
};

pub use request::{Headers, InvalidHeader, InvalidMethod, Method, Request};

pub use redirect::Redirect;

pub use response::{IntoResponse, Response, ResponseBody};

pub use route::{Route, RouteMethods};

pub use schemaval::{
    DecodeOptions, ExtraFields, Schema, SchemaField, SchemaKind, SchemaMetadata, UnknownFields,
    ValidationErrors, ValidationIssue, ValidationRule, Value, ValueSchema, Values,
};

pub use sse::{Sse, SseEvent, SseStream};

pub use serverkit_macros::Schema;

#[doc(hidden)]
pub use route::Routes;

pub(crate) use router::{Dispatch, Dispatcher, Scope};

pub use stream::{Chunk, RequestStream, ResponseStream, StreamError};

#[cfg(feature = "websocket")]
pub use websocket::{
    WebSocket, WebSocketError, WebSocketMessage, WebSocketUpgrade, WebSocketUpgradeError,
};

#[doc(hidden)]
pub mod adapter {
    #[cfg(feature = "websocket")]
    pub use crate::websocket::{WebSocketIo, WebSocketPlan};
}

pub mod prelude {
    pub use crate::{
        ApiKeyLocation, Body, Chunk, Config, DecodeOptions, Error, ErrorFormat, ExampleValue,
        ExtraFields, FromRequest, Handler, Header, HeaderError, Headers, IntoResponse, Method,
        Middleware, Next, OAuthFlow, OAuthFlows, OpenApi, OpenApiDocument, Operation,
        ParameterLocation, Path, PathError, Query, QueryError, Request, RequestStream, Response,
        ResponseBody, ResponseStream, Route, RouteMethods, Router, Scalar, ScalarDeveloperTools,
        Schema, SchemaField, SchemaKind, SchemaMetadata, SecurityRequirement, SecurityScheme,
        Server, StreamError, UnknownFields, ValidationErrors, ValidationIssue, ValidationRule,
        Value, ValueSchema, Values,
    };

    pub use crate::{
        Bytes, ConnectInfo, Cookie, Cookies, Extension, Form, FormError, InvalidHeader,
        InvalidMethod, MissingConnectInfo, MissingExtension, MissingState, Multipart,
        MultipartError, MultipartField, Redirect, SameSite, Sse, SseEvent, SseStream, State, Text,
        TextError,
    };

    #[cfg(feature = "json")]
    pub use crate::{Json, JsonError};

    #[cfg(feature = "websocket")]
    pub use crate::{
        WebSocket, WebSocketError, WebSocketMessage, WebSocketUpgrade, WebSocketUpgradeError,
    };
}