TideORM

A developer-friendly ORM for Rust with clean, expressive syntax.

Features

• Clean Model Definitions - Simple #[tideorm::model] attribute macro
• SeaORM-Style Relations - Define relations as struct fields
• Async-First - Built for modern async/await workflows
• Auto Schema Sync - Automatic table management during development
• Type Safe - Full Rust type safety with zero compromises
• Multi-Database - PostgreSQL, MySQL, and SQLite support
• Batteries Included:
  • Fluent Query Builder with Window Functions & CTEs
  • Database Migrations & Seeding
  • Model Validation System
  • Translations (i18n) for multilingual content
  • File Attachments with metadata
  • Full-Text Search with highlighting
  • Soft Deletes & Callbacks
  • Transaction Support

Quick Start

use tideorm::prelude::*;

#[tideorm::model]
#[tide(table = "users")]
pub struct User {
    #[tide(primary_key, auto_increment)]
    pub id: i64,
    pub email: String,
    pub name: String,
    pub active: bool,
    
    // Relations defined as struct fields
    #[tide(has_one = "Profile", foreign_key = "user_id")]
    pub profile: HasOne<Profile>,
    
    #[tide(has_many = "Post", foreign_key = "user_id")]
    pub posts: HasMany<Post>,
}

#[tideorm::model]
#[tide(table = "posts")]
pub struct Post {
    #[tide(primary_key, auto_increment)]
    pub id: i64,
    pub user_id: i64,
    pub title: String,
    
    #[tide(belongs_to = "User", foreign_key = "user_id")]
    pub author: BelongsTo<User>,
}

#[tokio::main]
async fn main() -> tideorm::Result<()> {
    // Connect with auto schema sync (development only!)
    TideConfig::init()
        .database("postgres://localhost/mydb")
        .sync(true)
        .connect()
        .await?;

    // Create
    let user = User {
        id: 0,
        email: "john@example.com".into(),
        name: "John Doe".into(),
        active: true,
        ..Default::default()
    };
    let user = user.save().await?;

    // Query
    let users = User::query()
        .where_eq("active", true)
        .order_desc("created_at")
        .limit(10)
        .get()
        .await?;

    // Complex queries with OR conditions
    let premium_or_featured = Product::query()
        .where_eq("active", true)
        .begin_or()
            .or_where_gt("price", 500.0).and_where_gte("rating", 4.5)
            .or_where_eq("featured", true)
        .end_or()
        .get()
        .await?;

    // Load relations
    let posts = user.posts.load().await?;
    let profile = user.profile.load().await?;

    // Update
    let mut user = User::find(1).await?.unwrap();
    user.name = "Jane Doe".into();
    user.update().await?;

    // Delete
    User::destroy(1).await?;

    Ok(())
}

Model Relations

TideORM supports SeaORM-style relations defined as struct fields:

#[tideorm::model]
#[tide(table = "users")]
pub struct User {
    #[tide(primary_key, auto_increment)]
    pub id: i64,
    pub name: String,
    
    // One-to-one: User has one Profile
    #[tide(has_one = "Profile", foreign_key = "user_id")]
    pub profile: HasOne<Profile>,
    
    // One-to-many: User has many Posts
    #[tide(has_many = "Post", foreign_key = "user_id")]
    pub posts: HasMany<Post>,
    
    // Many-to-many through pivot table
    #[tide(has_many_through = "Role", pivot = "user_roles", foreign_key = "user_id", related_key = "role_id")]
    pub roles: HasManyThrough<Role, UserRole>,
}

#[tideorm::model]
#[tide(table = "posts")]
pub struct Post {
    #[tide(primary_key, auto_increment)]
    pub id: i64,
    pub user_id: i64,
    pub title: String,
    
    // Inverse relation: Post belongs to User
    #[tide(belongs_to = "User", foreign_key = "user_id")]
    pub author: BelongsTo<User>,
}

// Loading relations
let user = User::find(1).await?.unwrap();
let posts = user.posts.load().await?;              // Vec<Post>
let profile = user.profile.load().await?;          // Option<Profile>

let post = Post::find(1).await?.unwrap();
let author = post.author.load().await?;            // Option<User>

// Check if relation exists
let has_posts = user.posts.exists().await?;        // bool
let post_count = user.posts.count().await?;        // u64

// Load with constraints
let recent_posts = user.posts.load_with(|q| {
    q.where_eq("published", true)
     .order_desc("created_at")
     .limit(5)
}).await?;

Installation

[dependencies]
# PostgreSQL (default)
tideorm = { version = "0.3", features = ["postgres"] }

# MySQL
tideorm = { version = "0.3", features = ["mysql"] }

# SQLite
tideorm = { version = "0.3", features = ["sqlite"] }

Feature Flags

Relation Types

Documentation

For detailed documentation on all features, see DOCUMENTATION.md.

Key sections:

• Configuration - Database connections and pool settings
• Model Definition - Defining your models
• Query Builder - Building complex queries
• OR Conditions - Fluent OR API with begin_or/end_or
• CRUD Operations - Create, Read, Update, Delete
• Soft Deletes - Soft delete support
• Transactions - Transaction handling
• Callbacks - Lifecycle hooks
• File Attachments - Manage file relationships
• Translations (i18n) - Multilingual content
• Validation - Data validation rules
• Full-Text Search - Search with highlighting
• Multi-Database - Cross-database compatibility

Examples & Testing

Run an example:

cargo run --example basic --features postgres

Run tests:

cargo test --features postgres

See the examples directory and DOCUMENTATION.md for more.

Rusty Rails Project

TideORM is part of the larger Rusty Rails project, which aims to bridge the gap between Rust and Ruby/Ruby on Rails ecosystems. We're actively working on recreating Ruby libraries in Rust to make working with Rust more easy and fun for new developers.

Related Projects

• More Rust libraries coming soon!

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Made with love by the Rusty Rails team