use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Query {
pub record_type: RecordType,
pub filter: Option<Filter>,
pub sort: Vec<Sort>,
pub limit: u32,
pub cursor: Option<Cursor>,
pub expand: Vec<Expand>,
pub version: VersionSelector,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RecordType {
Card,
Eval,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum VersionSelector {
#[default]
Latest,
All,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Expand {
Relations,
Badges,
Fingerprints,
Changed,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Filter {
And(Vec<Filter>),
Or(Vec<Filter>),
Not(Box<Filter>),
Cmp(Cmp),
Exists {
column: Column,
},
Any {
table: ArrayTable,
conditions: Vec<Cmp>,
},
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Cmp {
pub column: Column,
pub op: Op,
pub value: Value,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Op {
Eq,
Ne,
Gt,
Gte,
Lt,
Lte,
In,
Prefix,
Contains,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ArrayTable {
Results,
Relations,
Attachments,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Column {
Generated(String),
Fingerprint(String),
Ext {
path: Vec<String>,
ty: ValueType,
},
Body(Vec<String>),
Array(ArrayColumn),
Run(RunColumn),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RunColumn {
RunId,
Status,
ErrorKind,
StartedAt,
EndedAt,
Facet(Vec<String>),
Fingerprint(String),
Metric(String),
Result {
card: CardRef,
metric: String,
field: ResultField,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ResultField {
Value,
Label,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct CardRef(String);
impl CardRef {
pub fn parse(s: &str) -> Option<Self> {
evalhub_core::validate::is_valid_id(s).then(|| Self(s.to_string()))
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn ns(&self) -> &str {
self.0.split_once('/').map_or("", |(ns, _)| ns)
}
pub fn name(&self) -> &str {
self.0.split_once('/').map_or("", |(_, name)| name)
}
}
impl std::fmt::Display for CardRef {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::str::FromStr for CardRef {
type Err = InvalidCardRef;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::parse(s).ok_or_else(|| InvalidCardRef(s.to_string()))
}
}
impl TryFrom<String> for CardRef {
type Error = InvalidCardRef;
fn try_from(s: String) -> Result<Self, Self::Error> {
s.parse()
}
}
impl From<CardRef> for String {
fn from(card: CardRef) -> Self {
card.0
}
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
#[error("not a Card reference of the form {{ns}}/{{name}}: {0:?}")]
pub struct InvalidCardRef(pub String);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ArrayColumn {
ResultMetric,
ResultAggregation,
ResultValue,
ResultN,
RelationType,
RelationTo,
AttachmentPath,
AttachmentSha256,
}
impl ArrayColumn {
pub fn table(self) -> ArrayTable {
match self {
Self::ResultMetric | Self::ResultAggregation | Self::ResultValue | Self::ResultN => {
ArrayTable::Results
}
Self::RelationType | Self::RelationTo => ArrayTable::Relations,
Self::AttachmentPath | Self::AttachmentSha256 => ArrayTable::Attachments,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ValueType {
Number,
String,
Boolean,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Sort {
pub key: SortKey,
pub dir: Dir,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SortKey {
Column(Column),
Metric(String),
CreatedAt,
Run(RunColumn),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Dir {
Asc,
Desc,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Cursor {
pub keys: Vec<Value>,
pub version_id: uuid::Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RunQuery {
pub cards: Vec<CardRef>,
pub filter: Option<Filter>,
pub sort: Vec<Sort>,
pub limit: u32,
pub cursor: Option<RunCursor>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RunCursor {
pub keys: Vec<Value>,
pub run_id: String,
}