helix_db/helixc/generator/
utils.rs

1use std::fmt::{self, Debug, Display};
2
3use crate::helixc::parser::helix_parser::IdType;
4
5#[derive(Clone)]
6pub enum GenRef<T>
7where
8    T: Display,
9{
10    Literal(T),
11    Mut(T),
12    Ref(T),
13    RefLT(String, T),
14    DeRef(T),
15    MutRef(T),
16    MutRefLT(String, T),
17    MutDeRef(T),
18    RefLiteral(T),
19    Unknown,
20    Std(T),
21    Id(String),
22}
23
24impl<T> Display for GenRef<T>
25where
26    T: Display,
27{
28    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
29        match self {
30            GenRef::Literal(t) => write!(f, "\"{}\"", t),
31            GenRef::Std(t) => write!(f, "{}", t),
32            GenRef::Mut(t) => write!(f, "mut {}", t),
33            GenRef::Ref(t) => write!(f, "&{}", t),
34            GenRef::RefLT(lifetime_name, t) => write!(f, "&'{} {}", lifetime_name, t),
35            GenRef::DeRef(t) => write!(f, "*{}", t),
36            GenRef::MutRef(t) => write!(f, "& mut {}", t),
37            GenRef::MutRefLT(lifetime_name, t) => write!(f, "&'{} mut {}", lifetime_name, t),
38            GenRef::MutDeRef(t) => write!(f, "mut *{}", t),
39            GenRef::RefLiteral(t) => write!(f, "ref {}", t),
40            GenRef::Unknown => write!(f, ""),
41            GenRef::Id(id) => write!(f, "data.{}", id),
42        }
43    }
44}
45
46impl<T> GenRef<T>
47where
48    T: Display,
49{
50    pub fn inner(&self) -> &T {
51        match self {
52            GenRef::Literal(t) => t,
53            GenRef::Mut(t) => t,
54            GenRef::Ref(t) => t,
55            GenRef::RefLT(_, t) => t,
56            GenRef::DeRef(t) => t,
57            GenRef::MutRef(t) => t,
58            GenRef::MutRefLT(_, t) => t,
59            GenRef::MutDeRef(t) => t,
60            GenRef::RefLiteral(t) => t,
61            GenRef::Unknown => panic!("Cannot get inner of unknown"),
62            GenRef::Std(t) => t,
63            GenRef::Id(_) => panic!("Cannot get inner of unknown"),
64        }
65    }
66}
67impl<T> Debug for GenRef<T>
68where
69    T: Display,
70{
71    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
72        match self {
73            GenRef::Literal(t) => write!(f, "Literal({})", t),
74            GenRef::Std(t) => write!(f, "Std({})", t),
75            GenRef::Mut(t) => write!(f, "Mut({})", t),
76            GenRef::Ref(t) => write!(f, "Ref({})", t),
77            GenRef::RefLT(lifetime_name, t) => write!(f, "RefLT({}, {})", lifetime_name, t),
78            GenRef::DeRef(t) => write!(f, "DeRef({})", t),
79            GenRef::MutRef(t) => write!(f, "MutRef({})", t),
80            GenRef::MutRefLT(lifetime_name, t) => write!(f, "MutRefLT({}, {})", lifetime_name, t),
81            GenRef::MutDeRef(t) => write!(f, "MutDeRef({})", t),
82            GenRef::RefLiteral(t) => write!(f, "RefLiteral({})", t),
83            GenRef::Unknown => write!(f, "Unknown"),
84            GenRef::Id(id) => write!(f, "String({})", id),
85        }
86    }
87}
88impl From<GenRef<String>> for String {
89    fn from(value: GenRef<String>) -> Self {
90        match value {
91            GenRef::Literal(s) => format!("\"{}\"", s),
92            GenRef::Std(s) => format!("\"{}\"", s),
93            GenRef::Ref(s) => format!("\"{}\"", s),
94            _ => {
95                println!("Cannot convert to string: {:?}", value);
96                panic!("Cannot convert to string")
97            }
98        }
99    }
100}
101impl From<IdType> for GenRef<String> {
102    fn from(value: IdType) -> Self {
103        match value {
104            IdType::Literal { value: s, .. } => GenRef::Literal(s),
105            IdType::Identifier { value: s, .. } => GenRef::Id(s),
106            _ => panic!("Cannot convert to string: {:?}", value),
107        }
108    }
109}
110
111#[derive(Clone)]
112pub enum VecData {
113    Standard(GeneratedValue),
114    Embed(GeneratedValue),
115    Unknown,
116}
117
118impl Display for VecData {
119    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
120        match self {
121            VecData::Standard(v) => write!(f, "{}", v),
122            VecData::Embed(v) => write!(f, "&embed!(db, {})", v),
123            VecData::Unknown => panic!("Cannot convert to string, VecData is unknown"),
124        }
125    }
126}
127
128#[derive(Clone)]
129pub enum Order {
130    Asc,
131    Desc,
132}
133
134impl Display for Order {
135    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
136        match self {
137            Order::Asc => write!(f, "Asc"),
138            Order::Desc => write!(f, "Desc"),
139        }
140    }
141}
142
143pub fn write_properties(properties: &Option<Vec<(String, GeneratedValue)>>) -> String {
144    match properties {
145        Some(properties) => format!(
146            "Some(props! {{ {} }})",
147            properties
148                .iter()
149                .map(|(name, value)| format!("\"{}\" => {}", name, value))
150                .collect::<Vec<String>>()
151                .join(", ")
152        ),
153        None => "None".to_string(),
154    }
155}
156
157pub fn write_secondary_indices(secondary_indices: &Option<Vec<String>>) -> String {
158    match secondary_indices {
159        Some(indices) => format!(
160            "Some(&[{}])",
161            indices
162                .iter()
163                .map(|idx| format!("\"{}\"", idx))
164                .collect::<Vec<String>>()
165                .join(", ")
166        ),
167        None => "None".to_string(),
168    }
169}
170
171#[derive(Clone)]
172pub enum GeneratedValue {
173    // needed?
174    Literal(GenRef<String>),
175    Identifier(GenRef<String>),
176    Primitive(GenRef<String>),
177    Parameter(GenRef<String>),
178    Unknown,
179}
180impl GeneratedValue {
181    pub fn inner(&self) -> &GenRef<String> {
182        match self {
183            GeneratedValue::Literal(value) => value,
184            GeneratedValue::Primitive(value) => value,
185            GeneratedValue::Identifier(value) => value,
186            GeneratedValue::Parameter(value) => value,
187            GeneratedValue::Unknown => panic!("Cannot get inner of unknown"),
188        }
189    }
190}
191
192impl Display for GeneratedValue {
193    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
194        match self {
195            GeneratedValue::Literal(value) => write!(f, "{}", value),
196            GeneratedValue::Primitive(value) => write!(f, "{}", value),
197            GeneratedValue::Identifier(value) => write!(f, "{}", value),
198            GeneratedValue::Parameter(value) => write!(f, "{}", value),
199            GeneratedValue::Unknown => write!(f, ""),
200        }
201    }
202}
203impl Debug for GeneratedValue {
204    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
205        match self {
206            GeneratedValue::Literal(value) => write!(f, "Literal({})", value),
207            GeneratedValue::Primitive(value) => write!(f, "Primitive({})", value),
208            GeneratedValue::Identifier(value) => write!(f, "Identifier({})", value),
209            GeneratedValue::Parameter(value) => write!(f, "Parameter({})", value),
210            GeneratedValue::Unknown => write!(f, "Unknown"),
211        }
212    }
213}
214
215#[derive(Clone)]
216pub enum GeneratedType {
217    RustType(RustType),
218    Vec(Box<GeneratedType>),
219    Object(GenRef<String>),
220    Variable(GenRef<String>),
221}
222
223impl Display for GeneratedType {
224    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
225        match self {
226            GeneratedType::RustType(t) => write!(f, "{}", t),
227            GeneratedType::Vec(t) => write!(f, "Vec<{}>", t),
228            GeneratedType::Variable(v) => write!(f, "{}", v),
229            GeneratedType::Object(o) => write!(f, "{}", o),
230        }
231    }
232}
233
234#[derive(Clone)]
235pub enum RustType {
236    String,
237    I8,
238    I16,
239    I32,
240    I64,
241    U8,
242    U16,
243    U32,
244    U64,
245    U128,
246    F32,
247    F64,
248    Bool,
249    Uuid,
250    Date,
251}
252impl Display for RustType {
253    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
254        match self {
255            RustType::String => write!(f, "String"),
256            RustType::I8 => write!(f, "i8"),
257            RustType::I16 => write!(f, "i16"),
258            RustType::I32 => write!(f, "i32"),
259            RustType::I64 => write!(f, "i64"),
260            RustType::U8 => write!(f, "u8"),
261            RustType::U16 => write!(f, "u16"),
262            RustType::U32 => write!(f, "u32"),
263            RustType::U64 => write!(f, "u64"),
264            RustType::U128 => write!(f, "u128"),
265            RustType::F32 => write!(f, "f32"),
266            RustType::F64 => write!(f, "f64"),
267            RustType::Bool => write!(f, "bool"),
268            RustType::Uuid => write!(f, "ID"), // TODO: Change this for actual UUID
269            RustType::Date => write!(f, "DateTime<Utc>"),
270        }
271    }
272}
273impl RustType {
274    pub fn to_ts(&self) -> String {
275        let s = match self {
276            RustType::String => "string",
277            RustType::I8 => "number",
278            RustType::I16 => "number",
279            RustType::I32 => "number",
280            RustType::I64 => "number",
281            RustType::U8 => "number",
282            RustType::U16 => "number",
283            RustType::U32 => "number",
284            RustType::U64 => "number",
285            RustType::U128 => "number",
286            RustType::F32 => "number",
287            RustType::F64 => "number",
288            RustType::Bool => "boolean",
289            RustType::Uuid => "string", // do thee
290            RustType::Date => "Date",   // do thee
291        };
292        s.to_string()
293    }
294}
295
296#[derive(Clone)]
297pub enum Separator<T> {
298    Comma(T),
299    Semicolon(T),
300    Period(T),
301    Newline(T),
302    Empty(T),
303}
304impl<T: Display> Display for Separator<T> {
305    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
306        match self {
307            Separator::Comma(t) => write!(f, ",\n{}", t),
308            Separator::Semicolon(t) => write!(f, ";\n{}", t),
309            Separator::Period(t) => write!(f, "\n.{}", t),
310            Separator::Newline(t) => write!(f, "\n{}", t),
311            Separator::Empty(t) => write!(f, "{}", t),
312        }
313    }
314}
315impl<T: Display> Separator<T> {
316    pub fn inner(&self) -> &T {
317        match self {
318            Separator::Comma(t) => t,
319            Separator::Semicolon(t) => t,
320            Separator::Period(t) => t,
321            Separator::Newline(t) => t,
322            Separator::Empty(t) => t,
323        }
324    }
325}
326pub fn write_headers() -> String {
327    r#"
328
329use heed3::RoTxn;
330use helix_macros::{handler, tool_call, mcp_handler};
331use helix_db::{
332    helix_engine::{
333        graph_core::ops::{
334            bm25::search_bm25::SearchBM25Adapter,
335            g::G,
336            in_::{in_::InAdapter, in_e::InEdgesAdapter, to_n::ToNAdapter, to_v::ToVAdapter},
337            out::{
338                from_n::FromNAdapter, from_v::FromVAdapter, out::OutAdapter, out_e::OutEdgesAdapter,
339            },
340            source::{
341                add_e::{AddEAdapter, EdgeType},
342                add_n::AddNAdapter,
343                e_from_id::EFromIdAdapter,
344                e_from_type::EFromTypeAdapter,
345                n_from_id::NFromIdAdapter,
346                n_from_index::NFromIndexAdapter,
347                n_from_type::NFromTypeAdapter,
348            },
349            tr_val::{Traversable, TraversalVal},
350            util::{
351                dedup::DedupAdapter, drop::Drop, exist::Exist, filter_mut::FilterMut,
352                filter_ref::FilterRefAdapter, map::MapAdapter, paths::ShortestPathAdapter,
353                props::PropsAdapter, range::RangeAdapter, update::UpdateAdapter,
354            },
355            vectors::{
356                brute_force_search::BruteForceSearchVAdapter, insert::InsertVAdapter,
357                search::SearchVAdapter,
358            },
359        },
360        types::GraphError,
361        vector_core::vector::HVector,
362    },
363    helix_gateway::{
364        embedding_providers::embedding_providers::{EmbeddingModel, get_embedding_model},
365        router::router::HandlerInput,
366        mcp::mcp::{MCPHandlerSubmission, MCPToolInput, MCPHandler}
367    },
368    node_matches, props, embed,
369    field_remapping, identifier_remapping, 
370    traversal_remapping, exclude_field, value_remapping, 
371    protocol::{
372        remapping::{Remapping, RemappingMap, ResponseRemapping},
373        response::Response,
374        return_values::ReturnValue,
375        value::Value,
376    },
377    utils::{
378        count::Count,
379        filterable::Filterable,
380        id::ID,
381        items::{Edge, Node},
382    },
383};
384use sonic_rs::{Deserialize, Serialize};
385use std::collections::{HashMap, HashSet};
386use std::sync::Arc;
387use std::time::Instant;
388use chrono::{DateTime, Utc};
389    "#
390    .to_string()
391}
helix_db/helixc/generator/utils.rs

helix_db/helixc/generator/
utils.rs
