v0.1.0-alpha Lançado

O poder do Spring Data,
a precisão do Rust.

O padrão repository familiar para o ecossistema Rust. CRUD genérico para sqlx e MongoDB com segurança em tempo de compilação e zero boilerplate.

100% Tipo seguro

Zero Boilerplate

Any Backend

use rustdata::prelude::*;

#[derive(Entity, Debug)]
pub struct User {
    id: Uuid,
    email: String,
}

Integração perfeita com o ecossistema Rust

api Axum

bolt Tokio

timeline Tracing

data_object Serde

Escolha seu caminho

flight_takeoff

Migrando do Diesel?

Veja como nossa API mapeia os conceitos do Diesel e aprenda a migrar seus modelos.

Ler guia arrow_forward

dns

Escalando com MongoDB?

Descubra nossa integração NoSQL fluida e o suporte a tipos BSON.

Explorar NoSQL arrow_forward

school

Novo no Rust Data?

Comece com nosso guia rápido completo e construa seu primeiro app em minutos.

Início rápido arrow_forward

Acesso a dados, oxidado.

Pare de escrever as mesmas consultas básicas repetidamente. Foque na sua lógica de domínio enquanto o RustData cuida da camada de persistência.

database

Repositórios CRUD

save, find_by_id, find_all, update e delete gerados automaticamente.

code_blocks

Colunas type-safe

A validação de consultas em compilação evita erros em execução.

link

Joins/Relações

API ergonômica para Um-para-Muitos e Muitos-para-Muitos.

account_balance

Transações

Gestão transacional fluida entre operações.

delete_sweep

Exclusão lógica

Suporte integrado a padrões de exclusão lógica. Filtra automaticamente os registros excluídos sem modificar suas consultas.

api

Geração de API REST

Recurso opcional para gerar rotas axum automaticamente a partir dos seus repositórios.

transform

Migrações

Gestão de migrações de esquema integrada nativamente em código.

group_work

dns

Multi-tenancy e cache

Suporte de primeira classe para isolamento por tenant e camadas de cache distribuída (Redis/Memcached) integradas às abstrações de repositório.

Desempenho profissional

Abstrações de custo zero trazem a conveniência do padrão repository sem sacrificar o desempenho bruto do banco de dados.

Throughput (req/s) — maior é melhor

rustdata

95,420

sqlx (raw)

98,100

Diesel

89,200

SeaORM

75,300

* Benchmarks executados em AWS c6i.2xlarge contra Postgres 15. Consultas SELECT simples.

Como ele se compara

Escolher a crate de persistência certa é essencial. Veja onde o rustdata se encaixa no ecossistema de bancos de dados Rust em 2026.

Característica	rustdata	Diesel	SeaORM	sqlx	rusqlite
Categoria	cancel Fachada repository + ORM	cancel ORM completo (DSL tipada)	cancel ORM assíncrono (ActiveRecord)	cancel Toolkit SQL (não é um ORM)	cancel Wrapper leve de SQLite
Última versão	cancel v0.1.0-alpha	cancel 2.3.6	cancel 2.0	cancel 0.8.6	cancel 0.38.0
Backends	cancel SQL + MongoDB	cancel Apenas SQL	cancel Apenas SQL	cancel Postgres · MySQL · SQLite · MSSQL	cancel Apenas SQLite
Padrão repository e CRUD gerado	check_circle De primeira classe	cancel Manual	remove_circle_outline Active Record	cancel Manual	cancel Manual
Verificação em compilação	check_circle Queries validadas por macros	check_circle DSL tipada	cancel Só em execução	check_circle query! contra schema real	cancel Só em execução
Assíncrono por padrão	check_circle Sim	remove_circle_outline via diesel-async	check_circle Sim	check_circle Sim	cancel Não — só síncrono
Migrações integradas	check_circle Integradas	check_circle Integradas	check_circle Integradas	cancel De terceiros	cancel De terceiros
Curva de aprendizado	check_circle Baixa — estilo Spring	cancel Íngreme	check_circle Suave — devs Rails/Django	check_circle Baixa se você sabe SQL	cancel Mínima

* Panorama do início de 2026: Diesel 2.3.6 · SQLx 0.8.6 · SeaORM 2.0 · rusqlite 0.38.0.

psychology_alt

Máxima segurança em tempo de compilação?

A DSL tipada do Diesel verifica cada consulta contra seu schema — ao custo de uma curva de aprendizado mais íngreme.

edit_note

Prefere escrever SQL puro?

O sqlx valida queries cruas em compilação contra um schema real — mas repositórios e relações ficam por sua conta.

auto_awesome

Quer os dois — sem boilerplate?

O rustdata gera repositórios verificados em compilação sobre sqlx e MongoDB, com a ergonomia familiar do Spring.

code

Menos boilerplate.

USER_REPO.RS

use rustdata::prelude::*;

#[derive(Entity, Debug, Clone)]
pub struct User {
    pub id: Uuid,
    pub email: String,
    pub status: UserStatus,
}

// That's it. Generates findAll, findById, save, delete...
#[repository]
pub trait UserRepository: CrudRepository<User, Uuid> {
    // Custom queries are type-checked at compile time!
    async fn find_by_status(&self, status: UserStatus) -> Result<Vec<User>>;
}

GENERATED.SQL

SELECT id, email, status
FROM users
WHERE status = $1;

Prova em tempo de compilação

Capture erros antes da produção. Typos em queries falham na compilação.

cargo check

Compiling rustdata-example v0.1.0
error[E0412]: cannot find field `sttaus` in `User`
 --> src/repositories.rs:12:35
  |
12 |     async fn find_by_sttaus(&self, sttaus: UserStatus) -> Result<Vec<User>>;
  |                                   ^^^^^^ help: a field with a similar name exists: `status`
  |
  = note: rustdata macro generated query validation failed

error: could not compile `rustdata-example` due to previous error

Arquitetura de crate fachada

rustdata é uma crate fachada projetada para manter suas dependências limpas. Re-exporta elegantemente tudo que você precisa do nosso ecossistema modular.

rustdata-core // Traits and types
rustdata-macros // #[derive(Entity)], #[crud]
rustdata-migrations // Schema management

# Cargo.toml
[dependencies]
rustdata = { version = "0.1", features = ["postgres"] }
tokio = { version = "1.0", features = ["full"] }

Experiência de desenvolvedor

Persistência
declarativa

Defina suas entidades uma vez. Nossas macros poderosas geram implementações robustas e eficientes de repositórios em tempo de compilação.

check_circle Paginação e filtragem automáticos
check_circle Validação de schema em compilação
check_circle Assíncrono por padrão

src/main.rs RUST

// Migration
// CREATE TABLE users (id UUID PRIMARY KEY, name VARCHAR(255) NOT NULL);

use rustdata::prelude::*;

#[derive(Entity, Debug, Clone)]
pub struct User {
    id: Uuid,
    name: String,
}

#[crud(entity = User)]
trait UserRepository {}

#[tokio::main]
async fn main() -> Result<()> {
    let db = Database::connect("postgres://...").await?;
    let repo = UserRepositoryImpl::new(db);

    let user = User {
        id: Uuid::new_v4(),
        name: "Alice".to_string(),
    };

    repo.save(&user).await?;
    let found = repo.find_by_id(user.id).await?;

    Ok(())
}

O poder do Spring Data, a precisão do Rust.