Rust API reference

let app = App::new();

let main_namespace = app.main_namespace();

let main_namespace_mut = app.main_namespace_mut();

app.setup(|teo: Teo| async move {
    // list all users
    println!("{:?}", teo.user().find_many().await?);
    Ok(())
});

app.program("listAllUsers", Some("description"), |teo: Teo| async move {
    // list all users
    println!("{:?}", teo.user().find_many().await?);
    Ok(())
});

app.run().await

let namespace_path: Vec<&str> = namespace.path();

namespace.define_model_decorator("myDecorator", |arguments: Arguments, model: &mut Model| {
    model.data.insert("customDataKey".to_owned(), "customDataValue".into());
});

namespace.define_model_field_decorator("myDecorator", |arguments: Arguments, field: &mut Field| {
    field.data.insert("customDataKey".to_owned(), "customDataValue".into());
});

namespace.define_model_relation_decorator("myDecorator", |arguments: Arguments, relation: &mut Relation| {
    relation.data.insert("customDataKey".to_owned(), "customDataValue".into());
});

namespace.define_model_relation_decorator("myDecorator", |arguments: Arguments, relation: &mut Property| {
    property.data.insert("customDataKey".to_owned(), "customDataValue".into());
});

namespace.define_pipeline_item("today", |args: Arguments, ctx: Ctx| async move {
    Ok(Object::from(Utc::now().date_naive()))
});

app.main_namespace_mut().define_transform_pipeline_item("append0", |string: String| async {
    string + "0"
});

app.main_namespace_mut().define_transform_pipeline_item("abs", |i: i32| async {
    if i < 0 {
        Ok(i.abs())
    } else {
        Err(Error::new("cannot calculate"))
    }
});

app.main_namespace_mut().define_validator_pipeline_item("numberIsEven", |n: i32| async move {
    n % 2 == 0
});

app.main_namespace_mut().define_validator_pipeline_item("numberIsEven", |n: i32| async move {
    if n % 2 == 0 {
        None
    } else {
        Some("value is not even")
    }
});

app.main_namespace_mut().define_validator_pipeline_item("largerThan15", |i: i32| async move {
    if i < 0 {
        Err(Error::new("value is negative"))
    } else if i <= 15 {
        Ok(Some("value should be larger than 15".to_owned()))
    } else {
        Ok(None)
    }
});

app.main_namespace_mut().define_callback_pipeline_item("customCallback", |user: User| async {
    // do something with the value
    Ok(())
});

app.main_namespace_mut().define_callback_pipeline_item("customCallback", |user: User| async {
    if do_something() {
        Err(Error::new("error occurred"))
    } else {
        Ok(())
    }
});

app.main_namespace_mut().define_compare_pipeline_item("compare", |old: String, new: String| async {
    // do some callback with the old value and the new value
    // return a validation result if the new value is invalid
    Ok::<(), Error>(())
});

app.main_namespace_mut().define_middleware("timing", |arguments: Arguments| {
    Ok(middleware_wrap_fn(move |ctx: Ctx, next: &'static dyn Next| async move {
        let start = SystemTime::now();
        let res = next.call(ctx).await?;
        let end = SystemTime::now();
        let duration = end.duration_since(start).unwrap();
        println!("duration: {:?}", duration);
        return Ok(res);
    }))
});

app.main_namespace_mut().define_handler("myHandler", |request: Request, teo: Teo, ctx: Ctx| async move {
    let captures = ctx.handler_match().captures();
    Ok::<Response, Error>(Response::data(Value::String(captures.get("id").unwrap().to_owned())))
});

app.main_namespace_mut().define_handler_group("MyHandlerGroup", |group| {
    group.define_handler("myHandler", |request: Request, teo: Teo, ctx: Ctx| async move {
        let captures = ctx.handler_match().captures();
        Ok::<Response, Error>(Response::data(Value::String(captures.get("id").unwrap().to_owned())))
    });
});

app.main_namespace_mut().define_model_handler_group("User", |group| {
    group.define_handler("myHandler", |request: Request, teo: Teo, ctx: Ctx| async move {
        let captures = ctx.handler_match().captures();
        Ok::<Response, Error>(Response::data(Value::String(captures.get("id").unwrap().to_owned())))
    });
});

app.main_namespace_mut().define_handler_group("MyHandlerGroup", |group| {
    group.define_handler("myHandler", |request: Request, teo: Teo, ctx: Ctx| async move {
        let captures = ctx.handler_match().captures();
        Ok::<Response, Error>(Response::data(Value::String(captures.get("id").unwrap().to_owned())))
    });
});

Response::empty()

Response::string("Hello, world!", "text/plain")

Response::html("<html><body>Hello, world!</body></html>")

Response::file(PathBuf::from("a.txt"))

Response::redirect("https://example.com")

teon!({
    "name": "My name",
    "age": 12,
    "sex": Sex::MALE,
    "position": null,
})

pub async fn find_many(finder: &Value) -> Result<Vec<Self>>

let users = teo.user().find_many(&teon!({})).await?;

let users = teo.user().find_many(&teon!({
    "where": {
        "name": "John"
    }
})).await?;

let users = teo.user().find_many(&teon!({
    "orderBy": {
        "createdAt": "desc"
    }
})).await?;

let users = teo.user().find_many(&teon!({
    "include": {
        "posts": true
    }
})).await?

pub async fn find_unique(finder: &Value) -> Result<Option<Self>>

let user = teo.user().find_unique(&teon!({
    "where": {
        "id": 1
    }
})).await?;

pub async fn find_first(finder: &Value) -> Result<Option<Self>>

let user = teo.user().find_first(&teon!({
    "where": {
        "age": 20
    }
})).await?;

pub async fn count_objects(&self, query: impl Borrow<Value>) -> Result<usize>

let number_of_objects = teo.user().count_objects(teon!({})).await?;

pub async fn count_fields(&self, query: impl Borrow<Value>) -> Result<ModelCountAggregateResult>

let count_result = teo.user().count_fields(teon!({
    "select": {
        "createdAt": true
    }
})).await?;

pub async fn aggregate(&self, query: impl Borrow<Value>) -> Result<ModelAggregateResult>

let aggregate_result = teo.user().aggregate(teon!({})).await?;

pub async fn group_by(&self, query: impl Borrow<Value>) -> Result<Vec<ModelAggregateResult>>

let group_by_result = teo.record().group_by(teon!({
    "by": "name"
})).await?;

pub async fn new(values: impl AsRef<Value>) -> Self

let post = Post::new(teon!({ "title": "Post 1" })).await;

pub async fn default() -> Self

let post = Post::default().await;

pub async fn is_new(&self) -> bool

let is_new = post.is_new();

pub async fn is_modified(&self) -> bool

let is_modified = post.is_modified();

pub async fn set(&self, values: impl AsRef<Value>) -> Result<()>

user.set(teon!({ "name": "Peter", "age": 15 })).await?;

pub async fn update(&self, values: impl AsRef<Value>) -> Result<()>

user.update(teon!({ "name": "Peter", "age": 15 })).await?;

pub async fn save(&self) -> Result<()>

post.save().await?;

pub async fn delete(&self) -> Result<()>

post.delete().await?;

pub async fn to_teon(&self) -> Result<Value>

let value = object.to_teon().await?;