chore(rust): tidier libpk::main macro impl

crates/macros/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "pk_macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0"
+proc-macro2 = "1.0"
+syn = "2.0"
+

crates/macros/src/entrypoint.rs

@@ -0,0 +1,41 @@
+use proc_macro::{Delimiter, TokenTree};
+use quote::quote;
+
+pub fn macro_impl(
+    _args: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    // yes, this ignores everything except the codeblock
+    // it's fine.
+    let body = match input.into_iter().last().expect("empty") {
+        TokenTree::Group(group) if group.delimiter() == Delimiter::Brace => group.stream(),
+        _ => panic!("invalid function"),
+    };
+
+    let body = proc_macro2::TokenStream::from(body);
+
+    return quote! {
+        fn main() {
+            let _sentry_guard = libpk::init_sentry();
+            libpk::init_logging(env!("CARGO_CRATE_NAME"));
+            tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()
+                .unwrap()
+                .block_on(async {
+                    if let Err(error) = libpk::init_metrics() {
+                        tracing::error!(?error, "failed to init metrics collector");
+                    };
+
+                    tracing::info!("hello world");
+
+                    let result: anyhow::Result<()> = async { #body }.await;
+
+                    if let Err(error) = result {
+                        tracing::error!(?error, "failed to run service");
+                    };
+                });
+        }
+    }
+    .into();
+}

crates/macros/src/lib.rs

@@ -0,0 +1,14 @@
+use proc_macro::TokenStream;
+
+mod entrypoint;
+mod model;
+
+#[proc_macro_attribute]
+pub fn main(args: TokenStream, input: TokenStream) -> TokenStream {
+    entrypoint::macro_impl(args, input)
+}
+
+#[proc_macro_attribute]
+pub fn pk_model(args: TokenStream, input: TokenStream) -> TokenStream {
+    model::macro_impl(args, input)
+}

crates/macros/src/model.rs

@@ -0,0 +1,258 @@
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput, Expr, Ident, Meta, Type};
+
+#[derive(Clone, Debug)]
+enum ElemPatchability {
+    None,
+    Private,
+    Public,
+}
+
+#[derive(Clone, Debug)]
+struct ModelField {
+    name: Ident,
+    ty: Type,
+    patch: ElemPatchability,
+    json: Option<Expr>,
+    is_privacy: bool,
+    default: Option<Expr>,
+}
+
+fn parse_field(field: syn::Field) -> ModelField {
+    let mut f = ModelField {
+        name: field.ident.expect("field missing ident"),
+        ty: field.ty,
+        patch: ElemPatchability::None,
+        json: None,
+        is_privacy: false,
+        default: None,
+    };
+
+    for attr in field.attrs.iter() {
+        match &attr.meta {
+            Meta::Path(path) => {
+                let ident = path.segments[0].ident.to_string();
+                match ident.as_str() {
+                    "private_patchable" => match f.patch {
+                        ElemPatchability::None => {
+                            f.patch = ElemPatchability::Private;
+                        }
+                        _ => {
+                            panic!("cannot have multiple patch tags on same field");
+                        }
+                    },
+                    "patchable" => match f.patch {
+                        ElemPatchability::None => {
+                            f.patch = ElemPatchability::Public;
+                        }
+                        _ => {
+                            panic!("cannot have multiple patch tags on same field");
+                        }
+                    },
+                    "privacy" => f.is_privacy = true,
+                    _ => panic!("unknown attribute"),
+                }
+            }
+            Meta::NameValue(nv) => match nv.path.segments[0].ident.to_string().as_str() {
+                "json" => {
+                    if f.json.is_some() {
+                        panic!("cannot set json multiple times for same field");
+                    }
+                    f.json = Some(nv.value.clone());
+                }
+                "default" => {
+                    if f.default.is_some() {
+                        panic!("cannot set default multiple times for same field");
+                    }
+                    f.default = Some(nv.value.clone());
+                }
+                _ => panic!("unknown attribute"),
+            },
+            Meta::List(_) => panic!("unknown attribute"),
+        }
+    }
+
+    if matches!(f.patch, ElemPatchability::Public) && f.json.is_none() {
+        panic!("must have json name to be publicly patchable");
+    }
+
+    if f.json.is_some() && f.is_privacy {
+        panic!("cannot set custom json name for privacy field");
+    }
+
+    f
+}
+
+pub fn macro_impl(
+    _args: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    let model_type = match ast.data {
+        syn::Data::Struct(struct_data) => struct_data,
+        _ => panic!("pk_model can only be used on a struct"),
+    };
+
+    let tname = Ident::new(&format!("PK{}", ast.ident), Span::call_site());
+    let patchable_name = Ident::new(&format!("PK{}Patch", ast.ident), Span::call_site());
+
+    let fields = if let syn::Fields::Named(fields) = model_type.fields {
+        fields
+            .named
+            .iter()
+            .map(|f| parse_field(f.clone()))
+            .collect::<Vec<ModelField>>()
+    } else {
+        panic!("fields of a struct must be named");
+    };
+
+    // println!("{}: {:#?}", tname, fields);
+
+    let tfields = mk_tfields(fields.clone());
+    let from_json = mk_tfrom_json(fields.clone());
+    let _from_sql = mk_tfrom_sql(fields.clone());
+    let to_json = mk_tto_json(fields.clone());
+
+    let fields: Vec<ModelField> = fields
+        .iter()
+        .filter(|f| !matches!(f.patch, ElemPatchability::None))
+        .cloned()
+        .collect();
+
+    let patch_fields = mk_patch_fields(fields.clone());
+    let patch_from_json = mk_patch_from_json(fields.clone());
+    let patch_validate = mk_patch_validate(fields.clone());
+    let patch_to_json = mk_patch_to_json(fields.clone());
+    let patch_to_sql = mk_patch_to_sql(fields.clone());
+
+    return quote! {
+        #[derive(sqlx::FromRow, Debug, Clone)]
+        pub struct #tname {
+            #tfields
+        }
+
+        impl #tname {
+            pub fn from_json(input: String) -> Self {
+                #from_json
+            }
+
+            pub fn to_json(self) -> serde_json::Value {
+                #to_json
+            }
+        }
+
+        #[derive(Debug, Clone)]
+        pub struct #patchable_name {
+            #patch_fields
+        }
+
+        impl #patchable_name {
+            pub fn from_json(input: String) -> Self {
+                #patch_from_json
+            }
+
+            pub fn validate(self) -> bool {
+                #patch_validate
+            }
+
+            pub fn to_sql(self) -> sea_query::UpdateStatement {
+                // sea_query::Query::update()
+                    #patch_to_sql
+            }
+
+            pub fn to_json(self) -> serde_json::Value {
+                #patch_to_json
+            }
+        }
+    }
+    .into();
+}
+
+fn mk_tfields(fields: Vec<ModelField>) -> TokenStream {
+    fields
+        .iter()
+        .map(|f| {
+            let name = f.name.clone();
+            let ty = f.ty.clone();
+            quote! {
+                pub #name: #ty,
+            }
+        })
+        .collect()
+}
+fn mk_tfrom_json(_fields: Vec<ModelField>) -> TokenStream {
+    quote! { unimplemented!(); }
+}
+fn mk_tfrom_sql(_fields: Vec<ModelField>) -> TokenStream {
+    quote! { unimplemented!(); }
+}
+fn mk_tto_json(fields: Vec<ModelField>) -> TokenStream {
+    // todo: check privacy access
+    let fielddefs: TokenStream = fields
+        .iter()
+        .filter_map(|f| {
+            f.json.as_ref().map(|v| {
+                let tname = f.name.clone();
+                if let Some(default) = f.default.as_ref() {
+                    quote! {
+                        #v: self.#tname.unwrap_or(#default),
+                    }
+                } else {
+                    quote! {
+                        #v: self.#tname,
+                    }
+                }
+            })
+        })
+        .collect();
+
+    let privacyfielddefs: TokenStream = fields
+        .iter()
+        .filter_map(|f| {
+            if f.is_privacy {
+                let tname = f.name.clone();
+                let tnamestr = f.name.clone().to_string();
+                Some(quote! {
+                    #tnamestr: self.#tname,
+                })
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    quote! {
+        serde_json::json!({
+            #fielddefs
+            "privacy": {
+                #privacyfielddefs
+            }
+        })
+    }
+}
+
+fn mk_patch_fields(fields: Vec<ModelField>) -> TokenStream {
+    fields
+        .iter()
+        .map(|f| {
+            let name = f.name.clone();
+            let ty = f.ty.clone();
+            quote! {
+                pub #name: Option<#ty>,
+            }
+        })
+        .collect()
+}
+fn mk_patch_validate(_fields: Vec<ModelField>) -> TokenStream {
+    quote! { true }
+}
+fn mk_patch_from_json(_fields: Vec<ModelField>) -> TokenStream {
+    quote! { unimplemented!(); }
+}
+fn mk_patch_to_sql(_fields: Vec<ModelField>) -> TokenStream {
+    quote! { unimplemented!(); }
+}
+fn mk_patch_to_json(_fields: Vec<ModelField>) -> TokenStream {
+    quote! { unimplemented!(); }
+}