by-macros 0.3.2

#[cfg(feature = "server")]
use by_axum::aide;

use by_macros::api_model;
use serde::{Deserialize, Serialize};

type Result<T> = std::result::Result<T, by_types::ApiError<String>>;

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[cfg_attr(feature = "server", derive(schemars::JsonSchema, aide::OperationIo))]
#[api_model(base = "/topics/v1", iter_type=Vec)]
pub struct Topic {
    #[api_model(summary)]
    pub id: String,
    #[api_model(read_action = user_info)]
    pub wallet_address: String,
    #[api_model(read_action = [check_email,user_info])]
    pub email: String,
    #[api_model(summary, action = create)]
    pub title: String,
    #[api_model(summary, queryable, query_action = search_by, action = create, action_by_id = update)]
    pub description: String,
    #[api_model(summary, queryable, action_by_id = update, read_action = user_info)]
    pub status: i32,
    #[api_model(summary, query_action = [search_by, date_from])]
    pub created_at: i64,
    pub is_liked: bool,

    pub updated_at: i64,
    #[api_model(action_by_id = like, related = CommentRequest)]
    #[api_model(action = comment, related = Comment)]
    pub comments: Vec<Comment>,

    #[api_model(action_by_id = update)]
    pub tags: Vec<String>,
}

#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct Comment {
    pub id: String,
    pub content: String,
}

#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct CommentRequest {
    pub comment_id: String,
    pub is_liked: bool,
}

#[test]
fn test_macro_expansion_topic() {
    let _ = tracing_subscriber::fmt::try_init();

    let _read_action = TopicReadAction {
        action: Some(TopicReadActionType::CheckEmail),
        wallet_address: None,
        email: Some("test".to_string()),
        status: Some(1),
    };

    let _ = TopicReadAction::new().user_info("wallet".to_string(), "email".to_string(), 1);
    let _ = TopicReadAction::new().check_email("email".to_string());

    let q = TopicQuery {
        action: Some(TopicQueryActionType::DateFrom),
        size: 10,
        bookmark: None,
        description: None,
        status: Some(1),
        created_at: None,
    };

    assert_eq!(q.status, Some(1));
    assert_eq!(q.size, 10);
    assert_eq!(q.bookmark, None);
    assert_eq!(q.description, None);

    let _q = TopicQuery::new(10)
        .with_bookmark("test".to_string())
        .search_by("test".to_string(), 0);

    let q = TopicQuery::new(10)
        .with_bookmark("test".to_string())
        .date_from(1);

    let summary = TopicSummary::default();
    assert_eq!(summary.id, "".to_string());
    assert_eq!(summary.title, "".to_string());
    assert_eq!(summary.description, "".to_string());
    assert_eq!(summary.status, 0);
    assert_eq!(summary.created_at, 0);

    let create_request = TopicCreateRequest {
        title: "title".to_string(),
        description: "description".to_string(),
    };
    assert_eq!(create_request.title, "title".to_string());
    assert_eq!(create_request.description, "description".to_string());

    let update_request = TopicUpdateRequest {
        description: "description".to_string(),
        status: 1,
        tags: vec!["tag".to_string()],
    };
    assert_eq!(update_request.description, "description".to_string());
    assert_eq!(update_request.status, 1);
    assert_eq!(update_request.tags, vec!["tag".to_string()]);

    let create_request = TopicAction::Create(create_request);
    let update_request = TopicByIdAction::Update(update_request);
    let like_request = TopicByIdAction::Like(CommentRequest {
        comment_id: "1".to_string(),
        is_liked: true,
    });
    let comment_request = TopicAction::Comment(Comment {
        id: "1".to_string(),
        content: "content".to_string(),
    });

    let cli = Topic::get_client("");
    let _ = cli.get("1");
    let _ = cli.query(q);
    let _ = cli.act(create_request);
    let _ = cli.act(comment_request);
    let _ = cli.act_by_id("1", update_request);
    let _ = cli.act_by_id("1", like_request);
}

#[derive(Debug, Clone, serde::Deserialize, serde::Serialize, Default)]
#[cfg_attr(feature = "server", derive(schemars::JsonSchema, aide::OperationIo))]
#[api_model(base = "/users/v1", iter_type=Vec)]
pub struct User {
    pub created_at: u64,
    pub updated_at: u64,

    #[api_model(action = signup)]
    pub nickname: String,
    #[api_model(action = signup, read_action = [check_email, user_info])]
    pub email: String,
    #[api_model(action = signup)]
    pub profile_url: String,
}

#[test]
fn test_macro_expansion_user() {
    let _ = tracing_subscriber::fmt::try_init();

    let _ = User {
        created_at: 0,
        updated_at: 0,
        nickname: "nickname".to_string(),
        email: "email".to_string(),
        profile_url: "profile_url".to_string(),
    };

    let _ = UserReadAction {
        action: Some(UserReadActionType::CheckEmail),
        email: Some("email".to_string()),
    };
}