sift-query-derive 0.1.0

Derive macros for SiftQuery entities
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

use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::spanned::Spanned;
use syn::{GenericArgument, PathArguments, Type};

pub(crate) fn value_type_tokens(ty: &Type) -> syn::Result<TokenStream2> {
    let ident = outer_type_ident(ty)
        .ok_or_else(|| syn::Error::new(ty.span(), "unsupported query field type in M1"))?;
    let variant = match ident.as_str() {
        "bool" => quote!(Bool),
        "i32" => quote!(I32),
        "i64" => quote!(I64),
        "f32" => quote!(F32),
        "f64" => quote!(F64),
        "String" => quote!(Text),
        "Decimal" => quote!(Decimal),
        "NaiveDate" => quote!(Date),
        "NaiveTime" => quote!(Time),
        "NaiveDateTime" => quote!(DateTime),
        "DateTime" => quote!(Timestamp),
        "Uuid" => quote!(Uuid),
        "Value" => quote!(Json),
        "Int8Range" | "PgInt8Range" => quote!(Int8Range),
        "IpNet" => quote!(Network),
        "Vec" if is_vec_u8(ty) => quote!(Bytes),
        "Vec"
            if first_type_argument(ty)
                .and_then(|ty| unwrap_query_type(ty).ok())
                .and_then(outer_type_ident)
                .as_deref()
                == Some("i64") =>
        {
            quote!(ArrayI64)
        }
        "Vec"
            if first_type_argument(ty)
                .and_then(|ty| unwrap_query_type(ty).ok())
                .and_then(outer_type_ident)
                .as_deref()
                == Some("String") =>
        {
            quote!(ArrayText)
        }
        _ => {
            return Err(syn::Error::new(
                ty.span(),
                format!("unsupported query field type {ident} in M1"),
            ));
        }
    };
    Ok(quote!(::sift_query::__private::ValueType::#variant))
}

pub(crate) fn unwrap_query_type(ty: &Type) -> syn::Result<&Type> {
    match outer_type_ident(ty).as_deref() {
        Some("Option" | "FilterOnly") => first_type_argument(ty).ok_or_else(|| {
            syn::Error::new(ty.span(), "Option and FilterOnly require one type argument")
        }),
        _ => Ok(ty),
    }
}

fn first_type_argument(ty: &Type) -> Option<&Type> {
    let Type::Path(path) = ty else {
        return None;
    };
    let segment = path.path.segments.last()?;
    let PathArguments::AngleBracketed(arguments) = &segment.arguments else {
        return None;
    };
    arguments.args.iter().find_map(|argument| match argument {
        GenericArgument::Type(ty) => Some(ty),
        _ => None,
    })
}

pub(crate) fn outer_type_ident(ty: &Type) -> Option<String> {
    let Type::Path(path) = ty else {
        return None;
    };
    path.path
        .segments
        .last()
        .map(|segment| segment.ident.to_string())
}

fn is_vec_u8(ty: &Type) -> bool {
    first_type_argument(ty)
        .and_then(outer_type_ident)
        .as_deref()
        == Some("u8")
}