sea-orm-turso 0.2.0

# sea-orm-turso

A universal [SeaORM](https://docs.rs/sea-orm) adapter for [Turso Database](https://turso.tech).

## 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

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

## Quick Start

```rust
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

```rust
// 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

```rust
// 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:

```rust
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