[dependencies]
cratestack = { package = "cratestack-sqlite", version = "0.14", features = ["decimal-rust-decimal"] }
cratestack-macros = "0.14"
cratestack-rusqlite = "0.14"
serde = { version = "1", features = ["derive"] }
# Used by the examples below to build a `Uuid` id and a `DateTime` timestamp.
uuid = { version = "1", features = ["v4"] }
chrono = "0.4"

rustup target add wasm32-unknown-unknown
cargo build -p cratestack-rusqlite --target wasm32-unknown-unknown

datasource db {
  provider = "sqlite"
  url = env("DATABASE_URL")
}

auth Anonymous {
  id Int
}

model Note {
  id Uuid @id
  title String
  body String
  pinned Boolean
  createdAt DateTime
}

use cratestack_macros::include_embedded_schema;
use cratestack_rusqlite::ddl::create_table_sql;
use cratestack_rusqlite::{ModelDelegate, RusqliteRuntime};

include_embedded_schema!("schema.cstack");

fn open_store() -> Result<RusqliteRuntime, Box<dyn std::error::Error>> {
    // On a real device, resolve a writable path your platform considers
    // persistent: `Application.documentsDirectory` on iOS,
    // `Context.getFilesDir()` on Android.
    let runtime = RusqliteRuntime::open("app.db")?;

    // Bootstrap each table the schema defines. Idempotent — runs every
    // app start.
    runtime.with_connection(|conn| {
        conn.execute_batch(&create_table_sql(&cratestack_schema::NOTE_MODEL))?;
        Ok(())
    })?;

    Ok(runtime)
}

fn insert_one(runtime: &RusqliteRuntime) -> Result<(), Box<dyn std::error::Error>> {
    let notes = ModelDelegate::new(runtime, &cratestack_schema::NOTE_MODEL);
    let created = notes
        .create(cratestack_schema::CreateNoteInput {
            id: uuid::Uuid::new_v4(),
            title: "First note".into(),
            body: "Hello.".into(),
            pinned: true,
            createdAt: chrono::Utc::now(),
        })
        .run()?;
    println!("created note {}", created.id);
    Ok(())
}

use cratestack_macros::include_embedded_schema;
use cratestack_rusqlite::ddl::create_table_sql;
use cratestack_rusqlite::{opfs, ModelDelegate, RusqliteRuntime};

include_embedded_schema!("schema.cstack");

// Run inside a Dedicated Worker. The async step is one-time (per worker).
async fn open_store() -> Result<RusqliteRuntime, Box<dyn std::error::Error>> {
    opfs::install_opfs_vfs(&opfs::OpfsOptions::default()).await?;
    let runtime = RusqliteRuntime::open("app.db")?;
    runtime.with_connection(|conn| {
        conn.execute_batch(&create_table_sql(&cratestack_schema::NOTE_MODEL))?;
        Ok(())
    })?;
    Ok(runtime)
}

let pinned_first = notes
    .find_many()
    .where_(cratestack_schema::note::pinned().is_true())
    .order_by(cratestack_schema::note::createdAt().desc())
    .limit(20)
    .run()?;

use cratestack_rusqlite::ffi::{
    OperationRequest, OperationResponse, json_request_from, json_response_into,
};

// In your cdylib entry point (FFI) or wasm-bindgen module (browser):
fn ffi_call(runtime: &cratestack_rusqlite::RusqliteRuntime, bytes: &[u8]) -> Vec<u8> {
    let request = match json_request_from(bytes) {
        Ok(req) => req,
        Err(err) => return json_response_into(
            &OperationResponse::err("bad_request", err.to_string()),
        ),
    };
    json_response_into(&dispatch(runtime, request))
}