use std::borrow::Cow;
use std::collections::BTreeMap;
use std::str::FromStr;
use std::time::Duration;
use schemars::{json_schema, JsonSchema, Schema, SchemaGenerator};
use serde::Deserialize;
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct Spec {
pub feature: Option<String>,
pub kind: Option<Kind>,
pub name: Option<String>,
pub concurrency: Option<ConcurrencyKind>,
#[serde(default)]
pub events: Vec<EventSpec>,
pub state: Option<StateSpec>,
#[serde(default)]
pub models: Vec<TypeSpec>,
pub repository: Option<RepositorySpec>,
pub provider: Option<ProviderSpec>,
#[serde(default)]
pub dtos: Vec<TypeSpec>,
pub view: Option<ViewSpec>,
pub tests: Option<bool>,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum Kind {
#[default]
Bloc,
Cubit,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize)]
#[serde(try_from = "String")]
pub enum ConcurrencyKind {
#[default]
Sequential,
Droppable,
Restartable,
Concurrent,
Debounce(Duration),
Throttle(Duration),
}
impl FromStr for ConcurrencyKind {
type Err = String;
fn from_str(text: &str) -> Result<Self, String> {
let timed = |kind: &str, amount: &str| {
let invalid =
|| format!("`{text}`: use `{kind}:<n>ms` or `{kind}:<n>s` (`{kind}:300ms`)");
let (digits, unit): (&str, fn(u64) -> Duration) =
if let Some(digits) = amount.strip_suffix("ms") {
(digits, Duration::from_millis)
} else if let Some(digits) = amount.strip_suffix('s') {
(digits, Duration::from_secs)
} else {
return Err(invalid());
};
match digits.parse::<u64>() {
Ok(0) => Err(format!("`{text}`: the duration must be more than zero")),
Ok(count) => Ok(unit(count)),
Err(_) => Err(invalid()),
}
};
match text.split_once(':') {
None => match text {
"sequential" => Ok(Self::Sequential),
"droppable" => Ok(Self::Droppable),
"restartable" => Ok(Self::Restartable),
"concurrent" => Ok(Self::Concurrent),
_ => Err(format!(
"`{text}` is not sequential, droppable, restartable, concurrent, \
debounce:<duration> or throttle:<duration>"
)),
},
Some(("debounce", amount)) => timed("debounce", amount).map(Self::Debounce),
Some(("throttle", amount)) => timed("throttle", amount).map(Self::Throttle),
Some(_) => Err(format!(
"`{text}`: only debounce and throttle take a duration (`debounce:300ms`)"
)),
}
}
}
impl TryFrom<String> for ConcurrencyKind {
type Error = String;
fn try_from(text: String) -> Result<Self, String> {
text.parse()
}
}
impl JsonSchema for ConcurrencyKind {
fn schema_name() -> Cow<'static, str> {
"ConcurrencyKind".into()
}
fn json_schema(_: &mut SchemaGenerator) -> Schema {
json_schema!({
"type": "string",
"description": "`sequential`, `droppable`, `restartable`, `concurrent`, \
`debounce:300ms` or `throttle:1s`.",
"pattern": "^(sequential|droppable|restartable|concurrent|(debounce|throttle):[1-9][0-9]*(ms|s))$"
})
}
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct EventSpec {
pub name: String,
#[serde(default)]
pub fields: Vec<FieldSpec>,
pub calls: Option<String>,
pub concurrency: Option<ConcurrencyKind>,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct FieldSpec {
pub name: String,
#[serde(rename = "type")]
pub ty: String,
pub default: Option<String>,
pub rename: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct StateSpec {
pub style: Option<StateStyle>,
#[serde(default)]
pub status: Vec<String>,
#[serde(default)]
pub fields: Vec<FieldSpec>,
pub error: Option<String>,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum StateStyle {
#[default]
Struct,
Enum,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct TypeSpec {
pub name: String,
#[serde(default)]
pub fields: Vec<FieldSpec>,
#[serde(default)]
pub variants: Vec<TypeSpec>,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct RepositorySpec {
pub name: String,
#[serde(default)]
pub methods: Vec<MethodSpec>,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct MethodSpec {
pub name: String,
#[serde(default)]
pub args: Vec<FieldSpec>,
pub returns: Option<String>,
pub calls: Option<String>,
pub session: Option<SessionAction>,
pub token_field: Option<String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum SessionAction {
SignIn,
SignOut,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ProviderKind {
#[default]
Memory,
Http,
Db,
File,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct ProviderSpec {
pub name: String,
pub kind: Option<ProviderKind>,
pub api_base: Option<String>,
#[serde(default)]
pub endpoints: Vec<EndpointSpec>,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct EndpointSpec {
pub method: String,
pub verb: String,
pub path: String,
#[serde(default)]
pub path_params: Vec<FieldSpec>,
#[serde(default)]
pub query: Vec<FieldSpec>,
pub body: Option<String>,
#[serde(default)]
pub raw_body: bool,
pub response: String,
#[serde(default)]
pub skip_expire: bool,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct ViewSpec {
pub page: Option<bool>,
pub form: Option<FormSpec>,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct FormSpec {
pub event: String,
#[serde(default)]
pub fields: Vec<FieldSpec>,
pub server_errors: Option<ServerErrorsSpec>,
}
#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct ServerErrorsSpec {
pub conflict_field: Option<String>,
#[serde(default)]
pub field_map: BTreeMap<String, String>,
pub bad_request_field: Option<String>,
pub unauthorized_field: Option<String>,
}
pub fn schema() -> serde_json::Value {
serde_json::to_value(schemars::schema_for!(Spec)).unwrap_or_default()
}