Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::{ToTokens, format_ident, quote};
use syn::{
Data, DeriveInput, Fields, GenericArgument, LitStr, PathArguments, Type, parse_macro_input,
parse_quote,
};
#[proc_macro_derive(
MacroConfig,
attributes(macro_config_default, serde, from_ref, from_ref_all)
)]
pub fn derive_macro_config(input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as DeriveInput);
match expand_macro_config(input) {
Ok(tokens) => tokens.into(),
Err(error) => error.to_compile_error().into(),
}
}
fn expand_macro_config(input: DeriveInput) -> syn::Result<TokenStream2> {
let struct_name = input.ident;
let struct_name_string = struct_name.to_string();
let rename_all = serde_rename_all(&input.attrs)?;
// `#[from_ref_all]` on the struct opts every field into a generated `FromRef` impl, for
// fully-typed configs where each field is a distinct marker type. Individual fields can
// still opt in with `#[from_ref]` when the struct isn't fully typed yet.
let from_ref_all = has_from_ref_all(&input.attrs);
let fields = match input.data {
Data::Struct(data) => match data.fields {
Fields::Named(fields) => fields.named,
_ => {
return Err(syn::Error::new_spanned(
struct_name,
"MacroConfig only supports structs with named fields",
));
}
},
_ => {
return Err(syn::Error::new_spanned(
struct_name,
"MacroConfig only supports structs",
));
}
};
let mut field_data = Vec::new();
for (index, field) in fields.into_iter().enumerate() {
let ident = field.ident.ok_or_else(|| {
syn::Error::new_spanned(&field.ty, "MacroConfig only supports named fields")
})?;
let ty = field.ty;
let key = serde_rename(&field.attrs)?.unwrap_or_else(|| {
let field_name = ident.to_string();
apply_rename_all(&field_name, rename_all.as_deref())
});
let default = macro_config_default(&field.attrs)?;
let is_option = default.is_none() && is_option_type(&ty);
let from_ref = from_ref_all || has_from_ref(&field.attrs);
let variant = format_ident!("Field{index}");
field_data.push(FieldData {
ident,
ty,
key,
default,
is_option,
from_ref,
variant,
});
}
let field_keys = field_data.iter().map(|field| field.key.as_str());
let variants = field_data.iter().map(|field| &field.variant);
let field_matches = field_data.iter().map(|field| {
let key = field.key.as_str();
let variant = &field.variant;
quote! { #key => Ok(__MacroConfigField::#variant), }
});
let initializers = field_data.iter().map(|field| {
let ident = &field.ident;
quote! { let mut #ident = None; }
});
let value_matches = field_data.iter().map(|field| {
let FieldData {
ident,
ty,
key,
default,
variant,
..
} = field;
match default {
Some(default) => quote! {
__MacroConfigField::#variant => {
if #ident.is_some() {
return Err(<V::Error as ::macro_config::__serde::de::Error>::duplicate_field(#key));
}
#ident = Some(
map.next_value::<Option<#ty>>()?
.unwrap_or_else(|| #default)
);
}
},
None => quote! {
__MacroConfigField::#variant => {
if #ident.is_some() {
return Err(<V::Error as ::macro_config::__serde::de::Error>::duplicate_field(#key));
}
#ident = Some(map.next_value::<#ty>()?);
}
},
}
});
let finalizers = field_data.iter().map(|field| {
let FieldData {
ident,
ty,
key,
default,
is_option,
..
} = field;
match default {
Some(default) => quote! {
let #ident = #ident.unwrap_or_else(|| #default);
},
None if *is_option => quote! {
let #ident = #ident.unwrap_or(None);
},
None => quote! {
let #ident = match #ident {
Some(value) => value,
None => ::macro_config::__deserialize_missing_field::<#ty, V::Error>(#key)?,
};
},
}
});
let struct_fields = field_data.iter().map(|field| &field.ident);
let mut impl_generics_with_de = input.generics.clone();
impl_generics_with_de.params.insert(0, parse_quote!('de));
let (impl_generics, _, where_clause) = impl_generics_with_de.split_for_impl();
let (_, ty_generics, _) = input.generics.split_for_impl();
// Fields covered by FromRef each get a `macro_config::FromRef<Struct>` impl keyed on the
// field's type. Since the impl is type-keyed, two covered fields of the same type would
// collide (E0119), so reject that here with a clear message rather than a raw coherence error.
let mut seen_from_ref: std::collections::HashMap<String, ()> = std::collections::HashMap::new();
for field in field_data.iter().filter(|field| field.from_ref) {
let key = field.ty.to_token_stream().to_string();
if seen_from_ref.insert(key.clone(), ()).is_some() {
return Err(syn::Error::new_spanned(
&field.ty,
format!(
"duplicate FromRef field type `{key}`: every field covered by \
`#[from_ref]`/`#[from_ref_all]` must be a distinct type so \
`FromRef<{struct_name}>` is unambiguous"
),
));
}
}
let (from_ref_impl_generics, _, from_ref_where_clause) = input.generics.split_for_impl();
let from_ref_impls = field_data.iter().filter(|field| field.from_ref).map(|field| {
let ident = &field.ident;
let ty = &field.ty;
quote! {
impl #from_ref_impl_generics ::macro_config::FromRef<#struct_name #ty_generics> for #ty
#from_ref_where_clause
{
fn from_ref(env: &#struct_name #ty_generics) -> Self {
::core::clone::Clone::clone(&env.#ident)
}
}
}
});
let (inherent_impl_generics, inherent_ty_generics, inherent_where_clause) =
input.generics.split_for_impl();
let remote_secret_resolver_impl = if field_data
.iter()
.any(|field| is_remote_secret_type(&field.ty))
{
let bindings = field_data.iter().map(|field| &field.ident);
let field_initializers = field_data.iter().map(|field| {
let ident = &field.ident;
if is_remote_secret_type(&field.ty) {
quote! {
#ident: #ident.resolve_from_secret_manager(environment, secret_manager).await?,
}
} else {
quote! { #ident, }
}
});
quote! {
impl #inherent_impl_generics #struct_name #inherent_ty_generics #inherent_where_clause {
#[doc = "Resolve all `LocalOrRemoteSecret` fields through the provided secret manager."]
pub async fn resolve_remote_secrets<__MacroConfigSecretManager>(
self,
environment: ::macro_config::__macro_env::Environment,
secret_manager: &__MacroConfigSecretManager,
) -> ::core::result::Result<
Self,
<__MacroConfigSecretManager as ::macro_config::__remote_env_var::SecretManager>::Err,
>
where
__MacroConfigSecretManager: ::macro_config::__remote_env_var::SecretManager,
{
let Self { #(#bindings),* } = self;
::core::result::Result::Ok(Self {
#(#field_initializers)*
})
}
}
}
} else {
quote! {}
};
Ok(quote! {
impl #impl_generics ::macro_config::__serde::Deserialize<'de> for #struct_name #ty_generics #where_clause {
fn deserialize<__D>(deserializer: __D) -> Result<Self, __D::Error>
where
__D: ::macro_config::__serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[#(#field_keys),*];
enum __MacroConfigField {
#(#variants),*
}
impl<'de> ::macro_config::__serde::Deserialize<'de> for __MacroConfigField {
fn deserialize<__D>(deserializer: __D) -> Result<Self, __D::Error>
where
__D: ::macro_config::__serde::Deserializer<'de>,
{
struct __MacroConfigFieldVisitor;
impl<'de> ::macro_config::__serde::de::Visitor<'de> for __MacroConfigFieldVisitor {
type Value = __MacroConfigField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("a config field")
}
fn visit_str<__E>(self, value: &str) -> Result<Self::Value, __E>
where
__E: ::macro_config::__serde::de::Error,
{
match value {
#(#field_matches)*
_ => Err(__E::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(__MacroConfigFieldVisitor)
}
}
struct __MacroConfigVisitor;
impl<'de> ::macro_config::__serde::de::Visitor<'de> for __MacroConfigVisitor {
type Value = #struct_name #ty_generics;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str(concat!("struct ", #struct_name_string))
}
fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
where
V: ::macro_config::__serde::de::MapAccess<'de>,
{
#(#initializers)*
while let Some(key) = map.next_key::<__MacroConfigField>()? {
match key {
#(#value_matches)*
}
}
#(#finalizers)*
Ok(#struct_name {
#(#struct_fields),*
})
}
}
deserializer.deserialize_struct(#struct_name_string, FIELDS, __MacroConfigVisitor)
}
}
#(#from_ref_impls)*
#remote_secret_resolver_impl
})
}
struct FieldData {
ident: syn::Ident,
ty: Type,
key: String,
default: Option<TokenStream2>,
is_option: bool,
from_ref: bool,
variant: syn::Ident,
}
/// Whether a field is tagged with `#[from_ref]`, opting it into a generated
/// `macro_config::FromRef<Struct>` impl for its type.
fn has_from_ref(attrs: &[syn::Attribute]) -> bool {
attrs.iter().any(|attr| attr.path().is_ident("from_ref"))
}
/// Whether the struct is tagged with `#[from_ref_all]`, opting every field into a generated
/// `macro_config::FromRef<Struct>` impl. Requires all field types to be distinct.
fn has_from_ref_all(attrs: &[syn::Attribute]) -> bool {
attrs
.iter()
.any(|attr| attr.path().is_ident("from_ref_all"))
}
fn macro_config_default(attrs: &[syn::Attribute]) -> syn::Result<Option<TokenStream2>> {
let mut default = None;
for attr in attrs {
if attr.path().is_ident("macro_config_default") {
if default.is_some() {
return Err(syn::Error::new_spanned(
attr,
"duplicate macro_config_default attribute",
));
}
default = Some(attr.parse_args::<TokenStream2>()?);
}
}
Ok(default)
}
fn serde_rename_all(attrs: &[syn::Attribute]) -> syn::Result<Option<String>> {
let mut rename_all = None;
for attr in attrs {
if attr.path().is_ident("serde") {
attr.parse_nested_meta(|meta| {
if meta.path.is_ident("rename_all") {
let value = meta.value()?;
let value = value.parse::<LitStr>()?;
rename_all = Some(value.value());
}
Ok(())
})?;
}
}
Ok(rename_all)
}
fn serde_rename(attrs: &[syn::Attribute]) -> syn::Result<Option<String>> {
let mut rename = None;
for attr in attrs {
if attr.path().is_ident("serde") {
attr.parse_nested_meta(|meta| {
if meta.path.is_ident("rename") {
let value = meta.value()?;
let value = value.parse::<LitStr>()?;
rename = Some(value.value());
}
Ok(())
})?;
}
}
Ok(rename)
}
fn apply_rename_all(field_name: &str, rename_all: Option<&str>) -> String {
match rename_all {
Some("SCREAMING_SNAKE_CASE") => to_screaming_snake_case(field_name),
Some("lowercase") => field_name.to_ascii_lowercase(),
Some("snake_case") | None => field_name.to_string(),
_ => field_name.to_string(),
}
}
fn to_screaming_snake_case(value: &str) -> String {
let mut out = String::new();
let mut previous_was_lowercase_or_digit = false;
for ch in value.chars() {
if ch == '-' || ch == ' ' {
if !out.ends_with('_') {
out.push('_');
}
previous_was_lowercase_or_digit = false;
} else if ch.is_ascii_uppercase() {
if previous_was_lowercase_or_digit && !out.ends_with('_') {
out.push('_');
}
out.push(ch);
previous_was_lowercase_or_digit = false;
} else {
out.push(ch.to_ascii_uppercase());
previous_was_lowercase_or_digit = ch.is_ascii_lowercase() || ch.is_ascii_digit();
}
}
out
}
fn is_remote_secret_type(ty: &Type) -> bool {
let Type::Path(path) = ty else {
return false;
};
let Some(segment) = path.path.segments.last() else {
return false;
};
let ident = segment.ident.to_string();
ident == "LocalOrRemoteSecret" || ident == "OptionalLocalOrRemoteSecret"
}
fn is_option_type(ty: &Type) -> bool {
let Type::Path(path) = ty else {
return false;
};
let Some(segment) = path.path.segments.last() else {
return false;
};
if segment.ident != "Option" {
return false;
}
matches!(
&segment.arguments,
PathArguments::AngleBracketed(args)
if args.args.iter().any(|arg| matches!(arg, GenericArgument::Type(_)))
)
}