use std::time::Duration;
use serde::{Deserialize, Deserializer};
use crate::project::constants::{MAX_PERCENT, WHOLE_BATCH};
use crate::project::models::BatchStep;
pub(crate) fn deserialize_optional_duration<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Option<Duration>, D::Error> {
Option::<String>::deserialize(deserializer)?
.map(|text| humantime::parse_duration(&text).map_err(serde::de::Error::custom))
.transpose()
}
#[derive(Deserialize)]
#[serde(untagged)]
enum BatchText {
Duration(String),
Integer(u64),
}
pub(crate) fn deserialize_optional_batch<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Option<BatchStep>, D::Error> {
match Option::<BatchText>::deserialize(deserializer)? {
None => Ok(None),
Some(BatchText::Integer(0)) => Err(serde::de::Error::custom(
"batch_size must be a positive step",
)),
Some(BatchText::Integer(step)) => Ok(Some(BatchStep::Integer(step))),
Some(BatchText::Duration(text)) if text == WHOLE_BATCH => Ok(Some(BatchStep::Whole)),
Some(BatchText::Duration(text)) => match humantime::parse_duration(&text) {
Ok(step) if step.is_zero() => Err(serde::de::Error::custom(
"batch_size must be a positive duration",
)),
Ok(step) => Ok(Some(BatchStep::Duration(step))),
Err(error) => Err(serde::de::Error::custom(format!(
"batch_size {text:?} is not a duration such as \"1d\" or \"none\": {error}"
))),
},
}
}
#[derive(Deserialize)]
#[serde(untagged)]
enum OneOrMany {
One(String),
Many(Vec<String>),
}
pub(crate) fn deserialize_optional_keys<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Option<Vec<String>>, D::Error> {
Ok(
Option::<OneOrMany>::deserialize(deserializer)?.map(|keys| match keys {
OneOrMany::One(key) => vec![key],
OneOrMany::Many(keys) => keys,
}),
)
}
pub(crate) fn typed_constants(mut value: toml::Value) -> toml::Value {
let Some(toml::Value::Table(sources)) = value.get_mut("sources") else {
return value;
};
for source in sources
.iter_mut()
.filter_map(|(_, source)| source.as_table_mut())
{
if let Some(toml::Value::Table(constants)) = source.get_mut("constant_columns") {
*constants = typed_dates(std::mem::take(constants));
}
let tables = source
.get_mut("tables")
.and_then(toml::Value::as_table_mut)
.into_iter()
.flat_map(|tables| tables.iter_mut())
.filter_map(|(_, table)| table.as_table_mut());
for table in tables {
if let Some(toml::Value::Table(constants)) = table.get_mut("constant_columns") {
*constants = typed_dates(std::mem::take(constants));
}
}
}
value
}
fn typed_dates(constants: toml::Table) -> toml::Table {
constants
.into_iter()
.map(|(name, constant)| {
let toml::Value::Datetime(datetime) = constant else {
return (name, constant);
};
let written = match (datetime.date, datetime.time, datetime.offset) {
(Some(_), None, _) => "date",
(Some(_), Some(_), Some(_)) => "timestamp_tz",
(Some(_), Some(_), None) => "timestamp_ntz",
(None, _, _) => "time",
};
let typed = toml::Table::from_iter([
(
"value".to_owned(),
toml::Value::String(datetime.to_string()),
),
("type".to_owned(), toml::Value::String(written.to_owned())),
]);
(name, toml::Value::Table(typed))
})
.collect()
}
pub(crate) fn deserialize_optional_percent<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Option<u8>, D::Error> {
let Some(text) = Option::<String>::deserialize(deserializer)? else {
return Ok(None);
};
let parsed = text
.strip_suffix('%')
.map(|number| number.trim().parse::<u8>());
match parsed {
Some(Ok(percent)) if percent <= MAX_PERCENT => Ok(Some(percent)),
_ => Err(serde::de::Error::custom(format!(
"{text:?} is not a percentage; write a whole number from 0 to {MAX_PERCENT} followed by %, such as \"20%\""
))),
}
}