docs.rs failed to build sea-orm-turso-0.2.0
Please check the build logs for more information.
See Builds for ideas on how to fix a failed build, or Metadata for how to configure docs.rs builds.
If you believe this is docs.rs' fault, open an issue.

Visit the last successful build: sea-orm-turso-0.1.0

sea-orm-turso

A universal SeaORM adapter for Turso Database.

Features

MVCC: Full multi-version concurrency control via Turso engine
In-process: No network overhead, runs directly in your application
Async: Native async/await support via Tokio
WAL persistence: In-memory speed with file-based durability
Cloud sync: Optional sync with Turso Cloud (via turso::sync)
Universal: Works with any SeaORM-based framework (Loco, Axum, etc.)

Installation

[dependencies]
sea-orm-turso = "0.2"
sea-orm = "2.0"

Quick Start

use sea_orm_turso::TursoConnection;
use sea_orm::{EntityTrait, QueryFilter};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to a local Turso database
    let db = TursoConnection::connect("app.db").await?;

    // Use with SeaORM entities
    let users = user::Entity::find().all(&db).await?;

    Ok(())
}

Integration with Loco

// In your app.rs after_context hook:
use sea_orm_turso::TursoConnection;

async fn after_context(mut ctx: AppContext) -> Result<AppContext> {
    let turso = TursoConnection::connect("app.db").await.unwrap();
    ctx.shared_store.insert(turso);
    Ok(ctx)
}

API

Connection

// Connect to a file
let db = TursoConnection::connect("app.db").await?;

// Connect to memory (no persistence)
let db = TursoConnection::connect_memory().await?;

// From existing Turso database
let db = TursoConnection::from_existing(database, connection);

Usage with SeaORM

The TursoConnection implements SeaORM's ConnectionTrait and TransactionTrait, so it works seamlessly with all SeaORM APIs:

use sea_orm::{EntityTrait, QueryFilter, ActiveModelTrait, Set};

// Query
let users = user::Entity::find()
    .filter(user::Column::Name.contains("Bob"))
    .all(&db)
    .await?;

// Insert
let new_user = user::ActiveModel {
    name: Set("Alice".to_string()),
    email: Set("alice@example.com".to_string()),
    ..Default::default()
};
new_user.insert(&db).await?;

// Transaction
db.transaction(|txn| {
    Box::pin(async move {
        // Both operations in same transaction
        model1.insert(txn).await?;
        model2.insert(txn).await?;
        Ok(())
    })
}).await?;

Architecture

┌─────────────────────────────┐
│     Your SeaORM Code        │
├─────────────────────────────┤
│   TursoConnection           │  ← Implements ConnectionTrait
├─────────────────────────────┤
│   Turso Engine (MVCC)       │  ← In-process, async, concurrent writes
├─────────────────────────────┤
│   WAL → File Persistence    │  ← Survives restarts
└─────────────────────────────┘

License

MIT OR Apache-2.0

sea-orm-turso 0.2.0