premix-orm 1.0.6-alpha

Alpha research ORM for Rust. Facade crate for premix-core and premix-macros (not production-ready).
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

# Premix ORM


Premix ORM is a zero-overhead, type-safe ORM for Rust, designed for performance and developer experience.

This crate (`premix-orm`) is the official facade that re-exports `premix-core` and `premix-macros`, providing a unified entry point for your application.

## Research Status

This crate is part of a research prototype. APIs may change and production use is not recommended yet.

## Requirements

- Rust 1.85+ (edition 2024).
- No nightly toolchain required.

## Why use this facade?


- Unified imports: `use premix_orm::prelude::*;` gets you everything.
- No version mismatch: core and macros versions stay compatible.
- Clean dependencies: only one crate to add to your `Cargo.toml`.

## Installation


Add this to your `Cargo.toml`:

```toml
[dependencies]
premix-orm = "1.0.6-alpha"
sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
```

## Database Features


Enable database features on both `premix-orm` and `sqlx`:

```toml
premix-orm = { version = "1.0.6-alpha", features = ["postgres"] }
sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite", "postgres"] }
```

## Quick Start


```rust
use premix_orm::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Model, Debug, Serialize, Deserialize)]

pub struct User {
    pub id: i32,
    pub name: String,

    // Soft delete is auto-detected by field name.
    pub deleted_at: Option<String>,
}

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let pool = Premix::smart_sqlite_pool("sqlite::memory:").await?;

    // Sync schema.
    Premix::sync::<premix_orm::sqlx::Sqlite, User>(&pool).await?;

    // CRUD.
    let mut user = User { id: 0, name: "Alice".to_string(), deleted_at: None };
    user.save(&pool).await?;

    println!("Saved user with ID: {}", user.id);
    Ok(())
}
```

## Features


- Compile-time SQL generation via macros
- Application-level eager loading using batched queries
- Optional soft delete support by `deleted_at` convention
- SQLite, Postgres, and MySQL via `sqlx` feature flags

## Compatibility


- Requires `sqlx` with matching database features
- Works with the Tokio runtime

## Book


For a longer-form guide, see `orm-book/` in this repository.

## SQL Transparency

Inspect the SQL generated by the query builder:

```rust
let query = User::find_in_pool(&pool).filter_gt("age", 18).limit(10);
println!("{}", query.to_sql());
```

See the book for more on generated APIs and SQL inspection: `orm-book/src/queries.md`.

## Raw SQL Escape Hatch


Run raw SQL while mapping results to your model:

```rust
let users = User::raw_sql("SELECT * FROM users WHERE active = 1")
    .fetch_all(&pool)
    .await?;
```

## License


This project is licensed under the MIT license.