random ud

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "derive_http"
+name = "http_derive"
 version = "0.1.0"
 edition = "2024"
 
@@ -11,3 +11,4 @@ async-trait = "0.1.88"
 proc-macro2 = "1.0.95"
 quote = "1.0.40"
 syn = { version = "2.0.104", features = ["full"] }
+http_core = { path = "../http_core" }

src/lib.rs

@@ -2,8 +2,9 @@ use proc_macro::TokenStream;
 use quote::quote;
 use syn::{parse_macro_input, Lit, ItemEnum, DeriveInput, Fields, Data};
 use quote::format_ident;
+use http_core::{Queryable, ApiDispatch, HasHttp, Keys};
 
-#[proc_macro_derive(HttpRequest, attributes(http_get, http_response, http_error_type))]
+#[proc_macro_derive(HttpRequest, attributes(http_response, http_error_type))]
 pub fn derive_http_get_request(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     let query_name = &input.ident;
@@ -25,19 +26,10 @@ pub fn derive_http_get_request(input: TokenStream) -> TokenStream {
         }
     }
 
-    // Determine response type name
+    let response_name_str = response_name_opt.unwrap_or_else(|| format!("{}Resp", query_name_str));
-    let response_name_str = if let Some(custom_resp) = response_name_opt {
-        custom_resp
-    } else if query_name_str == "Q" {
-        "R".to_string()
-    } else if query_name_str.ends_with('Q') {
-        format!("{}R", &query_name_str[..query_name_str.len() - 1])
-    } else {
-        panic!("HttpRequest derive macro expects the type name to be 'Q' or end with 'Q', or specify #[http_response = \"...\"] to override");
-    };
     let response_name = format_ident!("{}", response_name_str);
 
-    // Parse optional #[http_error_type = "..."] attribute (default to `current_mod::E`)
+    // Parse optional #[http_error_type = "..."] attribute (default to `E`)
     let mut error_type = syn::Path::from(syn::Ident::new("E", proc_macro2::Span::call_site()));
     for attr in &input.attrs {
         if attr.path().is_ident("http_error_type") {
@@ -53,25 +45,7 @@ pub fn derive_http_get_request(input: TokenStream) -> TokenStream {
         }
     }
 
-    // Extract base URL from #[http_get(url = "...")]
+    // Collect query parameters from lnk_p_* fields
-    let mut base_url = None;
-    for attr in &input.attrs {
-        if attr.path().is_ident("http_get") {
-            attr.parse_nested_meta(|meta| {
-                if meta.path.is_ident("url") {
-                    let lit: Lit = meta.value()?.parse()?;
-                    if let Lit::Str(litstr) = lit {
-                        base_url = Some(litstr.value());
-                    }
-                }
-                Ok(())
-            }).unwrap_or_else(|e| panic!("Error parsing http_get attribute: {}", e));
-        }
-    }
-    let base_url = base_url.expect("Missing #[http_get(url = \"...\")] attribute");
-    let base_url_lit = syn::LitStr::new(&base_url, proc_macro2::Span::call_site());
-
-    // Collect query parameters from fields named "lnk_p_*" (only for structs)
     let query_param_code = if let Data::Struct(data_struct) = &input.data {
         if let Fields::Named(fields_named) = &data_struct.fields {
             fields_named.named.iter().filter_map(|field| {
@@ -80,7 +54,9 @@ pub fn derive_http_get_request(input: TokenStream) -> TokenStream {
                 if field_name.starts_with("lnk_p_") {
                     let key = &field_name["lnk_p_".len()..];
                     Some(quote! {
-                        query_params.push((#key.to_string(), self.#ident.to_string()));
+                        if let Some(val) = &self.#ident {
+                            query_params.push((#key.to_string(), val.to_string()));
+                        }
                     })
                 } else {
                     None
@@ -100,15 +76,16 @@ pub fn derive_http_get_request(input: TokenStream) -> TokenStream {
 
             async fn send(
                 &self,
+                base_url: &str,
                 headers: Option<Vec<(&str, &str)>>,
-            ) -> Result<Self::R, #error_type> {  // Use the error type here
+            ) -> Result<Self::R, #error_type> {
                 use awc::Client;
                 use urlencoding::encode;
 
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 #(#query_param_code)*
 
-                let mut url = #base_url_lit.to_string();
+                let mut url = base_url.to_string();
                 if !query_params.is_empty() {
                     let mut query_string = String::new();
                     let mut first = true;
@@ -134,7 +111,6 @@ pub fn derive_http_get_request(input: TokenStream) -> TokenStream {
 
                 let response = request.send().await?;
                 let bytes = response.body().await?;
-
                 let parsed: Self::R = serde_json::from_slice(&bytes)?;
                 Ok(parsed)
             }
@@ -144,6 +120,7 @@ pub fn derive_http_get_request(input: TokenStream) -> TokenStream {
     TokenStream::from(expanded)
 }
 
+
 #[proc_macro_attribute]
 pub fn alpaca_cli(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let input_enum = parse_macro_input!(item as ItemEnum);