feat(config): add validated profile core

libs/kaptan-config-derive/src/expand.rs

@@ -0,0 +1,187 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::Result;
+
+use crate::parse::{Check, Model};
+
+pub(crate) fn expand(model: Model) -> Result<TokenStream> {
+    let Model {
+        ident,
+        generics,
+        crate_path,
+        post_validate,
+        fields,
+    } = model;
+    let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
+    let mut checks = Vec::new();
+    let mut descriptors = Vec::new();
+    for field in fields {
+        let FieldMetadata {
+            descriptor,
+            checks: field_checks,
+        } = expand_field(&crate_path, &field)?;
+        if let Some(descriptor) = descriptor {
+            descriptors.push(descriptor);
+        }
+        checks.extend(field_checks);
+    }
+    let post_validate = post_validate.map(|hook| quote! { #hook(self)?; });
+    Ok(quote! {
+        impl #impl_generics #crate_path::ValidateFields for #ident #type_generics #where_clause {
+            fn validate_fields(&self) -> Result<(), #crate_path::ConfigViolation> {
+                #(#checks)*
+                #post_validate
+                Ok(())
+            }
+        }
+
+        impl #impl_generics #ident #type_generics #where_clause {
+            /// Field metadata generated from the same attributes as validation.
+            pub const DESCRIPTORS: &'static [#crate_path::FieldDescriptor] = &[
+                #(#descriptors),*
+            ];
+        }
+    })
+}
+
+struct FieldMetadata {
+    descriptor: Option<TokenStream>,
+    checks: Vec<TokenStream>,
+}
+
+fn expand_field(crate_path: &syn::Path, field: &crate::parse::FieldModel) -> Result<FieldMetadata> {
+    let mut checks = Vec::new();
+    let Some(id) = field.id else {
+        return Ok(FieldMetadata {
+            descriptor: None,
+            checks,
+        });
+    };
+    let minimum = field.checks.iter().find_map(|check| match check {
+        Check::Minimum(value) => Some(value),
+        _ => None,
+    });
+    let maximum = field.checks.iter().find_map(|check| match check {
+        Check::Maximum(value) => Some(value),
+        _ => None,
+    });
+    for check in &field.checks {
+        checks.push(expand_check(crate_path, &field.ident, id, check.clone()));
+    }
+    let key = field.display_key.as_ref().expect("id fields have a key");
+    let unit = field.unit.as_ref().expect("id fields have a unit");
+    let default = field.default.as_ref().expect("id fields have a default");
+    let (kind, value) = config_value_tokens(crate_path, &field.ty)?;
+    let minimum = option_value_tokens(value.clone(), minimum);
+    let maximum = option_value_tokens(value.clone(), maximum);
+    Ok(FieldMetadata {
+        descriptor: Some(quote! {
+            #crate_path::FieldDescriptor {
+                id: #crate_path::FieldId::new(#id),
+                display_key: #key,
+                kind: #kind,
+                minimum: #minimum,
+                maximum: #maximum,
+                default: #value(#default),
+                unit: #unit,
+                apply_policy: #crate_path::ApplyPolicy::RestartRequired,
+            }
+        }),
+        checks,
+    })
+}
+
+fn option_value_tokens(value: TokenStream, expression: Option<&syn::Expr>) -> TokenStream {
+    match expression {
+        Some(expression) => quote! { Some(#value(#expression)) },
+        None => quote! { None },
+    }
+}
+
+fn config_value_tokens(
+    crate_path: &syn::Path,
+    ty: &syn::Type,
+) -> Result<(TokenStream, TokenStream)> {
+    let syn::Type::Path(path) = ty else {
+        return Err(syn::Error::new_spanned(
+            ty,
+            "configuration metadata requires a scalar type",
+        ));
+    };
+    let Some(segment) = path.path.segments.last() else {
+        return Err(syn::Error::new_spanned(
+            ty,
+            "configuration metadata requires a scalar type",
+        ));
+    };
+    let (kind, value) = match segment.ident.to_string().as_str() {
+        "bool" => (
+            quote! { #crate_path::ValueKind::Bool },
+            quote! { #crate_path::ConfigValue::Bool },
+        ),
+        "i32" => (
+            quote! { #crate_path::ValueKind::I32 },
+            quote! { #crate_path::ConfigValue::I32 },
+        ),
+        "u32" => (
+            quote! { #crate_path::ValueKind::U32 },
+            quote! { #crate_path::ConfigValue::U32 },
+        ),
+        "u64" => (
+            quote! { #crate_path::ValueKind::U64 },
+            quote! { #crate_path::ConfigValue::U64 },
+        ),
+        "f32" => (
+            quote! { #crate_path::ValueKind::F32 },
+            quote! { #crate_path::ConfigValue::F32 },
+        ),
+        "f64" => (
+            quote! { #crate_path::ValueKind::F64 },
+            quote! { #crate_path::ConfigValue::F64 },
+        ),
+        _ => {
+            return Err(syn::Error::new_spanned(
+                ty,
+                "configuration metadata supports bool, i32, u32, u64, f32, and f64",
+            ));
+        }
+    };
+    Ok((kind, value))
+}
+
+fn expand_check(crate_path: &syn::Path, field: &syn::Ident, id: u16, check: Check) -> TokenStream {
+    match check {
+        Check::Finite => quote! {
+            if !self.#field.is_finite() {
+                return Err(#crate_path::ConfigViolation::field(
+                    #crate_path::FieldId::new(#id),
+                    #crate_path::ValidationRule::NonFinite,
+                ));
+            }
+        },
+        Check::Nonzero => quote! {
+            if self.#field == 0 {
+                return Err(#crate_path::ConfigViolation::field(
+                    #crate_path::FieldId::new(#id),
+                    #crate_path::ValidationRule::Zero,
+                ));
+            }
+        },
+        Check::Minimum(minimum) => quote! {
+            if self.#field < (#minimum) {
+                return Err(#crate_path::ConfigViolation::field(
+                    #crate_path::FieldId::new(#id),
+                    #crate_path::ValidationRule::BelowMinimum,
+                ));
+            }
+        },
+        Check::Maximum(maximum) => quote! {
+            if self.#field > (#maximum) {
+                return Err(#crate_path::ConfigViolation::field(
+                    #crate_path::FieldId::new(#id),
+                    #crate_path::ValidationRule::AboveMaximum,
+                ));
+            }
+        },
+    }
+}