sql-fun 0.1.0

SQL query/statement execution code generator
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
139
140
141
142
143
144
145
146

use quote::ToTokens;
use syn::{
    FnArg, GenericArgument, GenericParam, Ident, ItemFn, Pat, Path, PathArguments, Type,
    TypeParamBound, TypePath, WherePredicate, punctuated::Punctuated,
};

pub fn get_function_output_type(item_fn: &ItemFn) -> Option<TypePath> {
    let return_type = item_fn.sig.output.clone();
    let syn::ReturnType::Type(_, ty) = return_type else {
        return None;
    };
    let syn::Type::Path(ty_path) = *ty else {
        return None;
    };
    Some(ty_path)
}
/// returns T of Result<T,E>
pub fn get_result_type_value(type_path: &TypePath) -> Option<Type> {
    let last_segment = type_path.path.segments.last()?;
    let PathArguments::AngleBracketed(args) = &last_segment.arguments else {
        return None;
    };
    let GenericArgument::Type(ty) = args.args.iter().next()? else {
        return None;
    };
    Some(ty.clone())
}

/// returns T of Result<T,E>
pub fn get_result_type_error(type_path: &TypePath) -> Option<Type> {
    let last_segment = type_path.path.segments.last()?;
    let PathArguments::AngleBracketed(args) = &last_segment.arguments else {
        return None;
    };
    let GenericArgument::Type(ty) = args.args.iter().nth(1)? else {
        return None;
    };
    Some(ty.clone())
}

/// returns (T,E) for `fn somewhat() -> Result<T,E> ` syntax
pub fn get_result_types(item_fn: &ItemFn) -> Option<(Type, Type)> {
    let type_path = get_function_output_type(item_fn)?;
    let value_type = get_result_type_value(&type_path)?;
    let error_type = get_result_type_error(&type_path)?;
    Some((value_type, error_type))
}

pub fn get_last_parameter_type_from_fn_trait(
    handler_ty: Punctuated<TypeParamBound, syn::token::Plus>,
) -> Option<Path> {
    handler_ty.iter().find_map(|f| {
        let TypeParamBound::Trait(tb) = f else {
            return None;
        };
        let seg = tb.path.segments.first()?;

        if seg.ident != "Fn" {
            return None;
        };
        let PathArguments::Parenthesized(pga) = &seg.arguments else {
            return None;
        };
        let Type::Path(p) = pga.inputs.last()? else {
            return None;
        };
        Some(p.path.clone())
    })
}

fn get_generic_where_bounds(
    function_ast: &ItemFn,
    name: &String,
) -> Option<Punctuated<syn::TypeParamBound, syn::token::Plus>> {
    let Some(where_clause) = &function_ast.sig.generics.where_clause else {
        return None;
    };
    where_clause.predicates.iter().find_map(|p| {
        let WherePredicate::Type(pt) = p else {
            return None;
        };
        // Check if the type name matches `name`
        if pt.bounded_ty.clone().to_token_stream().to_string() != *name {
            return None;
        }
        if pt.bounds.is_empty() {
            return None;
        }
        Some(pt.bounds.clone())
    })
}

fn get_generic_param_bounds(
    function_ast: &ItemFn,
    name: &String,
) -> Option<Punctuated<syn::TypeParamBound, syn::token::Plus>> {
    let handler_ty = &function_ast.sig.generics.params.iter().find_map(|p| {
        let GenericParam::Type(gp) = p else {
            return None;
        };

        if gp.ident == *name {
            if gp.bounds.is_empty() {
                None
            } else {
                Some(gp.bounds.clone())
            }
        } else {
            None
        }
    });
    handler_ty.clone()
}

pub fn get_generic_type_bounds(
    function_ast: &ItemFn,
    type_name: &String,
) -> Option<Punctuated<syn::TypeParamBound, syn::token::Plus>> {
    get_generic_param_bounds(function_ast, type_name)
        .or_else(|| get_generic_where_bounds(function_ast, type_name))
}

pub fn get_last_parameter_type(function_ast: &ItemFn) -> Option<Ident> {
    let last_arg = function_ast.sig.inputs.last()?;
    let FnArg::Typed(last_arg_type) = last_arg else {
        return None;
    };
    let Type::Path(ref ty_path) = *last_arg_type.ty else {
        return None;
    };
    Some(ty_path.path.segments[0].ident.clone())
}

pub fn get_last_parameter_name(function_ast: &ItemFn) -> Option<Ident> {
    function_ast.sig.inputs.last().and_then(get_arg_name)
}

pub fn get_arg_name(fn_arg: &FnArg) -> Option<Ident> {
    let FnArg::Typed(arg_typed) = fn_arg else {
        return None;
    };
    let Pat::Ident(ref arg_ident) = *arg_typed.pat else {
        return None;
    };
    Some(arg_ident.ident.clone())
}