fusion-common 0.1.0

A data fusion platform with scheduler, ai agent studio and core libraries
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::ops::Deref;

use serde::{Deserialize, Serialize};

// region:    --- OrderBy
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "with-openapi", derive(utoipa::ToSchema))]
#[cfg_attr(target_arch = "wasm32", derive(tsify::Tsify), tsify(into_wasm_abi, from_wasm_abi))]
#[serde(transparent)]
pub struct OrderBy(String);

impl OrderBy {
  pub fn to_sql(&self) -> String {
    if let Some(stripped) = self.0.strip_prefix('!') { format!("{} desc", stripped) } else { format!("{} asc", self.0) }
  }
}

impl From<&str> for OrderBy {
  fn from(value: &str) -> Self {
    Self(value.to_string())
  }
}

impl From<&String> for OrderBy {
  fn from(value: &String) -> Self {
    Self(value.to_string())
  }
}

impl From<String> for OrderBy {
  fn from(value: String) -> Self {
    Self(value)
  }
}

impl Deref for OrderBy {
  type Target = String;

  fn deref(&self) -> &Self::Target {
    &self.0
  }
}
// endregion: --- OrderBy

// region:    --- OrderBys
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "with-openapi", derive(utoipa::ToSchema))]
#[cfg_attr(target_arch = "wasm32", derive(tsify::Tsify), tsify(into_wasm_abi, from_wasm_abi))]
#[serde(transparent)]
pub struct OrderBys(Vec<OrderBy>);

impl Default for OrderBys {
  fn default() -> Self {
    OrderBys::new(vec![])
  }
}

impl OrderBys {
  pub fn new(v: Vec<OrderBy>) -> Self {
    OrderBys(v)
  }

  pub fn into_inner(self) -> Vec<OrderBy> {
    self.0
  }

  pub fn is_empty(&self) -> bool {
    self.0.is_empty()
  }
}

// This will allow us to iterate over &OrderBys
impl<'a> IntoIterator for &'a OrderBys {
  type Item = &'a OrderBy;
  type IntoIter = std::slice::Iter<'a, OrderBy>;

  fn into_iter(self) -> Self::IntoIter {
    self.0.iter()
  }
}

// This will allow us to iterate over OrderBys directly (consuming it)
impl IntoIterator for OrderBys {
  type Item = OrderBy;
  type IntoIter = std::vec::IntoIter<OrderBy>;

  fn into_iter(self) -> Self::IntoIter {
    self.0.into_iter()
  }
}

// NOTE: If we want the Vec<T> and T, we have to make the individual from
//       specific to the type. Otherwise, conflict.

impl From<&str> for OrderBys {
  fn from(val: &str) -> Self {
    OrderBys(vec![val.into()])
  }
}
impl From<&String> for OrderBys {
  fn from(val: &String) -> Self {
    OrderBys(vec![val.into()])
  }
}
impl From<String> for OrderBys {
  fn from(val: String) -> Self {
    OrderBys(vec![val.into()])
  }
}

impl From<OrderBy> for OrderBys {
  fn from(val: OrderBy) -> Self {
    OrderBys(vec![val])
  }
}

impl From<Vec<&str>> for OrderBys {
  fn from(val: Vec<&str>) -> Self {
    let d = val.into_iter().map(OrderBy::from).collect::<Vec<_>>();
    OrderBys(d)
  }
}

impl From<Vec<&String>> for OrderBys {
  fn from(val: Vec<&String>) -> Self {
    let d = val.into_iter().map(OrderBy::from).collect::<Vec<_>>();
    OrderBys(d)
  }
}

impl From<Vec<String>> for OrderBys {
  fn from(val: Vec<String>) -> Self {
    let d = val.into_iter().map(OrderBy::from).collect::<Vec<_>>();
    OrderBys(d)
  }
}

// endregion: --- OrderBys