rapina - GitLite

KO | EN

gitlite — search

#javascript #python #react #ai #typescript #golang #android #linux #nodejs #awesome #cli #security #pytorch #openai

rapina

(★ 177)

A Rust web framework for APIs. So simple it feels like cheating.

파일 탐색기

최종 버전 다운로드 (.zip)

- - bug_report.yml
  - config.yml
  - feature_request.yml
  - good_first_issue.yml
  - question.yml
  - suggestion.yml
- - audit.yml
  - ci.yml
  - docs.yml
  - issue-claim.yml
  - labeler.yml
  - release.yml
  - scorecard.yml
  - welcome.yml
- CODEOWNERS
- dependabot.yml
- FUNDING.yml
- labeler.yml
- PULL_REQUEST_TEMPLATE.md
- WEEKLY_CHANGELOG_TEMPLATE.md
- - _index.md
  - changelog.md
  - support.md
- - style.scss
- - CNAME
- - base.html
  - blog-post.html
  - blog-section.html
  - changelog.html
  - docs-base.html
  - docs-section.html
  - index.html
  - page.html
  - roadmap-section.html
  - roadmap.html
  - section.html
  - support.html
  - taxonomy_list.html
  - taxonomy_single.html
  - tutorial.html
- CNAME
- config.toml
- - router.rs
- - auth.rs
  - endpoint_groups.rs
  - error_formats.rs
  - hello.rs
  - json.rs
  - macros.rs
  - middleware.rs
  - multi_path_params.rs
  - multipart.rs
  - pagination.rs
  - sse.rs
  - telemetry.rs
  - todo_api.rs
  - validation.rs
- - app.rs
  - cache.rs
  - cache_redis.rs
  - config.rs
  - context.rs
  - cron_scheduler.rs
  - database.rs
  - date_cache.rs
  - discovery.rs
  - error.rs
  - handler.rs
  - lib.rs
  - migration.rs
  - pagination.rs
  - server.rs
  - state.rs
  - test.rs
  - websocket.rs
- - cache.rs
  - discovery.rs
  - error_handling.rs
  - extractors.rs
  - jobs.rs
  - llms.rs
  - metrics.rs
  - metrics_discovery.rs
  - middleware.rs
  - migration_test.rs
  - multipart.rs
  - pagination.rs
  - relay.rs
  - relay_channels.rs
  - routing.rs
  - schema_test.rs
  - serialization.rs
  - streaming.rs
  - websocket.rs
- Cargo.toml
- - colors.rs
  - main.rs
- Cargo.toml
- juca.txt
- - config.rs
  - lib.rs
  - relay.rs
- Cargo.toml
.gitignore
Cargo.lock
Cargo.toml
CHANGELOG.md
CONTRIBUTING.md
deny.toml
justfile
LICENSE
README.md
rust-toolchain.toml
SECURITY.md

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<p align="center">
  <img src="docs/static/images/logo.png" alt="Rapina" width="120" />
</p>

<h1 align="center">Rapina</h1>

<p align="center">
  <strong>A Rust web framework for APIs. So simple it feels like cheating.</strong>
</p>

<p align="center">
  <a href="https://crates.io/crates/rapina"><img src="https://img.shields.io/crates/v/rapina.svg" alt="Crates.io"></a>
  <a href="https://docs.rs/rapina"><img src="https://docs.rs/rapina/badge.svg" alt="Documentation"></a>
  <a href="https://github.com/rapina-rs/rapina/actions/workflows/ci.yml"><img src="https://github.com/rapina-rs/rapina/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
  <a href="https://discord.gg/Z4ww64YBQj"><img src="https://img.shields.io/badge/Discord-Join-5865F2?logo=discord&logoColor=white" alt="Discord"></a>
  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
</p>

---

```rust
use rapina::prelude::*;

#[get("/users")]
async fn list_users(db: Db) -> Result<Json<Vec<User>>> {
    let users = User::find_all(db.conn()).await?;
    Ok(Json(users))
}

#[post("/users")]
async fn create_user(input: Validated<Json<CreateUser>>, db: Db) -> Result<Json<User>> {
    let user = User::create(db.conn(), input.into_inner()).await?;
    Ok(Json(user))
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    Rapina::new()
        .discover()
        .listen("127.0.0.1:3000")
        .await
}
```

No router configuration. No manual wiring. Annotate your handlers, call `.discover()`, ship.

## Get started

```bash
cargo install rapina-cli
rapina new my-app
cd my-app
rapina dev
```

Your API is running. That's it.

## What you get

**Auto-discovery** — annotate handlers with `#[get]`, `#[post]`, `#[put]`, `#[delete]`. Rapina finds them at startup. Your `main.rs` stays three lines.

**Database from day one** — define your schema declaratively. `author: User` becomes a foreign key. `posts: Vec<Post>` becomes a relationship. SeaORM entities are auto-generated.

```rust
schema! {
    User {
        name: String,
        email: String,
        posts: Vec<Post>
    }

Post {
        title: String,
        body: String,
        author: User
    }
}
```

**Auth that works** — JWT authentication, protected by default. Mark public routes with `#[public]`. Access the current user with the `CurrentUser` extractor.

```rust
#[public]
#[post("/login")]
async fn login(body: Json<LoginRequest>, auth: State<AuthConfig>) -> Result<Json<TokenResponse>> {
    let token = auth.create_token(&body.username)?;
    Ok(Json(TokenResponse::new(token, auth.expiration())))
}

#[get("/me")]
async fn me(user: CurrentUser) -> Json<UserResponse> {
    Json(UserResponse { id: user.id })
}
```

**CRUD in one command** — scaffold an entire resource with handlers, DTOs, errors, schema, and migration.

```bash
rapina add resource Post
```

**OpenAPI built-in** — spec generation, breaking change detection, and validation from the CLI.

```bash
rapina openapi export -o openapi.json
rapina openapi diff --base main
```

**Production middleware** — rate limiting, compression, CORS out of the box. Prometheus metrics available with the `metrics` feature flag.

```rust
Rapina::new()
    .with_rate_limit(RateLimitConfig::per_minute(100))
    .with_compression(CompressionConfig::default())
    .with_cors(CorsConfig::permissive())
    .with_metrics(true)  // Requires `metrics` feature flag
    .discover()
    .listen("0.0.0.0:3000")
    .await
```

**CLI for everything** — create, develop, test, inspect, generate.

```bash
rapina new my-app              # Scaffold a new project
rapina dev                     # Dev server with hot reload
rapina test --coverage         # Tests with coverage report
rapina test --watch            # Watch mode
rapina routes                  # List all routes
rapina doctor                  # Health checks and diagnostics
rapina migrate new             # Create a migration
rapina add resource Post       # Full CRUD scaffolding
```

## Built-in extractors

Everything you need to pick apart a request, type-safe and compile-time checked.

`Json<T>` · `Path<T>` · `Query<T>` · `Headers` · `Cookie<T>` · `State<T>` · `CurrentUser` · `Db`  · `... and more`

See the [extractors documentation](https://userapina.com/docs/core-concepts/extractors/) for the full list.

## Standardized errors

Every error includes a `trace_id`. No more guessing in production.

```json
{
  "error": { "code": "NOT_FOUND", "message": "user not found" },
  "trace_id": "550e8400-e29b-41d4-a716-446655440000"
}
```

## Project status

Rapina is in active development with a rapid release cadence. The API is stabilizing but breaking changes may still occur before `1.0.0`.

See the [roadmap](https://userapina.com/roadmap/) for what's coming next.

## Documentation

Full documentation at [userapina.com](https://userapina.com/)

- [Getting Started](https://userapina.com/docs/getting-started/)
- [Database](https://userapina.com/docs/core-concepts/database/)
- [Authentication](https://userapina.com/docs/core-concepts/authentication/)
- [CLI Reference](https://userapina.com/docs/cli/)
  
## Contributing

Contributions are welcome. Check out the [open issues](https://github.com/rapina-rs/rapina/issues) or join us on [Discord](https://discord.gg/Z4ww64YBQj).

## License

MIT