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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
//! Cot is an easy to use, modern, and fast web framework for Rust. It has
//! been designed to be familiar if you've ever used
//! [Django](https://www.djangoproject.com/), and easy to learn if you haven't.
//! It's a batteries-included framework built on top of
//! [axum](https://github.com/tokio-rs/axum).
//!
//! ## Features
//!
//! * **Easy to use API** — in many ways modeled after Django, Cot's API is
//! designed to be easy to use and intuitive. Sensible defaults make it for
//! easy rapid development, while the API is still empowering you when needed.
//! The documentation is a first-class citizen in Cot, making it easy to find
//! what you're looking for.
//! * **ORM integration** — Cot comes with its own ORM, allowing you to interact
//! with your database in a way that feels Rusty and intuitive. Rust types are
//! the source of truth, and the ORM takes care of translating them to and
//! from the database, as well as creating the migrations automatically.
//! * **Type safe** — wherever possible, Cot uses Rust's type system to prevent
//! common mistakes and bugs. Not only views are taking advantage of the
//! Rust's type system, but also the ORM, the admin panel, and even the
//! templates. All that to catch errors as early as possible.
//! * **Admin panel** — Cot comes with an admin panel out of the box, allowing
//! you to manage your app's data with ease. Adding new models to the admin
//! panel is stupidly simple, making it a great tool not only for rapid
//! development and debugging, but with its customization options, also for
//! production use.
//! * **Secure by default** — security should be opt-out, not opt-in. Cot takes
//! care of making your web apps secure by default, defending it against
//! common modern web vulnerabilities. You can focus on building your app, not
//! securing it.
//!
//! ## Guide
//!
//! This is an API reference for Cot, which might not be the best place to
//! start learning Cot. For a more gentle introduction, see the
//! [Cot guide](https://cot.rs/guide/latest/).
//!
//! ## Examples
//!
//! To see examples of how to use Cot, see the
//! [examples in the repository](https://github.com/cot-rs/cot/tree/master/examples).
extern crate self as cot;
// Not public API. Referenced by macro-generated code.
pub
pub use aide;
pub use bytes;
/// A wrapper around a handler that's used in [`Bootstrapper`].
///
/// It is returned by [`Bootstrapper::finish`]. Typically, you don't need to
/// interact with this type directly, except for creating it in
/// [`Project::middlewares`] through the
/// [`RootHandlerBuilder::build`](crate::project::RootHandlerBuilder::build)
/// method.
///
/// # Examples
///
/// ```
/// use cot::config::ProjectConfig;
/// use cot::{Bootstrapper, BoxedHandler, Project};
///
/// struct MyProject;
/// impl Project for MyProject {}
///
/// # #[tokio::main]
/// # async fn main() -> cot::Result<()> {
/// let bootstrapper = Bootstrapper::new(MyProject)
/// .with_config(ProjectConfig::default())
/// .boot()
/// .await?;
/// let handler: BoxedHandler = bootstrapper.finish().handler;
/// # Ok(())
/// # }
/// ```
pub use BoxedHandler;
pub use RequestHandler;
pub use json;
pub use ;
/// An attribute macro that defines an end-to-end test function for a
/// Cot-powered app.
///
/// This is primarily useful for use with the
/// [`TestServerBuilder`](cot::test::TestServerBuilder) struct, which allows you
/// to run a full-fledged Cot server in a test environment.
///
/// Internally, this is equivalent to `#[tokio::test]` with the test body
/// wrapped in a [`tokio::task::LocalSet`] to allow for running non-`Send` async
/// code in the test.
///
/// # Examples
///
/// ```
/// use cot::test::TestServerBuilder;
///
/// struct TestProject;
/// impl cot::Project for TestProject {}
///
/// #[cot::e2e_test]
/// async fn test_server() -> cot::Result<()> {
/// let server = TestServerBuilder::new(TestProject).start().await;
///
/// server.close().await;
/// Ok(())
/// }
/// ```
pub use e2e_test;
/// An attribute macro that defines an entry point to a Cot-powered app.
///
/// This macro is meant to wrap a function returning a structure implementing
/// [`cot::Project`]. It should just initialize a [`cot::Project`] and return
/// it, while the macro takes care of initializing an async runtime, creating a
/// CLI and running the app.
///
/// # Examples
///
/// ```no_run
/// use cot::project::RegisterAppsContext;
/// use cot::{App, AppBuilder, Project};
///
/// struct HelloApp;
///
/// impl App for HelloApp {
/// fn name(&self) -> &'static str {
/// env!("CARGO_PKG_NAME")
/// }
/// }
///
/// struct HelloProject;
/// impl Project for HelloProject {
/// fn register_apps(&self, apps: &mut AppBuilder, _context: &RegisterAppsContext) {
/// apps.register_with_views(HelloApp, "");
/// }
/// }
///
/// #[cot::main]
/// fn main() -> impl Project {
/// HelloProject
/// }
/// ```
pub use main;
pub use test;
pub use http;
pub use schemars;
pub use crate;
pub use crate;