feat: add support to known if env is default or not (#23)

Author: rsfreitas

examples/apps/grpc_with_lifecycle/src/main.rs

@@ -71,7 +71,7 @@ impl lifecycle::Lifecycle for Context {
     async fn on_start(&mut self, ctx: Arc<context::Context>) -> errors::Result<()> {
         println!("grpc on_start called");
         self.value = 42;
-        self.greeter = Some(link_grpc_service!(ctx, GreeterClient, "greeter"));
+        //        self.greeter = Some(link_grpc_service!(ctx, GreeterClient, "greeter"));
         Ok(())
     }
 

examples/apps/http_with_protobuf/src/api/router.rs

@@ -1,13 +1,13 @@
 // Code generated by protoc-gen-mikros-extensions. DO NOT EDIT.
 
-use axum::Json;
 use axum::extract::Path;
 use axum::extract::{Extension, State};
 use axum::http::header::HeaderMap;
 use axum::routing::{delete, get, post, put};
+use axum::Json;
 use mikros::tonic::Request;
-use mikros::{Deserialize, Serialize};
 use mikros::{axum, errors, http::ServiceState};
+use mikros::{Deserialize, Serialize};
 use std::sync::Arc;
 
 use crate::card;
@@ -291,10 +291,9 @@ impl Router {
     pub fn routes(self) -> axum::Router<Arc<mikros::Mutex<ServiceState>>> {
         axum::Router::new()
             .route("/card/v1/cards", post(create_card))
-            .route("/card/v1/cards/:id", get(get_card))
-            .route("/card/v1/cards/:id", put(update_card))
-            .route("/card/v1/cards/:id", delete(delete_card))
+            .route("/card/v1/cards/{id}", get(get_card))
+            .route("/card/v1/cards/{id}", put(update_card))
+            .route("/card/v1/cards/{id}", delete(delete_card))
             .layer(Extension(self.clone()))
     }
 }
-

examples/apps/native/service.toml

@@ -6,10 +6,10 @@ types = ["native"]
 envs = [ "CUSTOM_ENV" ]
 
 [features.simple_api]
-enabled = false
+enabled = true
 collections = [ "name1", "name2" ]
 
 [features.another_api]
 enabled = true
 use_tls = true
-host = "localhost"
+host = "localhost"

mikros-macros/Cargo.toml

@@ -15,9 +15,6 @@ categories.workspace = true
 proc-macro = true
 
 [dependencies]
-proc-macro2 = "1.0.92"
+proc-macro2 = "1.0.93"
 quote = "1.0.38"
 syn = "2.0.96"
-
-[dev-dependencies]
-mikros-tests = { workspace = true }

mikros-macros/src/env.rs

@@ -6,7 +6,7 @@ use syn::DeriveInput;
 
 pub fn generate(input: DeriveInput) -> TokenStream {
     let struct_name = input.ident.clone();
-    let (field_initializers, attributes) = match parser::parse_fields(input) {
+    let (field_initializers, default_checks, attributes) = match parser::parse_fields(input) {
         Ok(fields) => fields,
         Err(err) => panic!("{}", err),
     };
@@ -41,6 +41,12 @@ pub fn generate(input: DeriveInput) -> TokenStream {
 
                 std::env::var(key)
             }
+
+            pub fn check_defaults(&self) -> Vec<(&'static str, bool)> {
+                vec![
+                    #(#default_checks),*
+                ]
+            }
         }
     };
 

mikros-macros/src/env/parser.rs

@@ -77,7 +77,7 @@ impl Default for StructAttributes {
     }
 }
 
-pub(crate) fn parse_fields(input: DeriveInput) -> Result<(Vec<TokenStream>, StructAttributes), String> {
+pub(crate) fn parse_fields(input: DeriveInput) -> Result<(Vec<TokenStream>, Vec<TokenStream>, StructAttributes), String> {
     let struct_name = &input.ident;
 
     // Parse struct level attributes
@@ -90,11 +90,16 @@ pub(crate) fn parse_fields(input: DeriveInput) -> Result<(Vec<TokenStream>, Stru
     };
 
     let mut field_initializers: Vec<TokenStream> = Vec::new();
+    let mut default_checks: Vec<TokenStream> = Vec::new();
+
     for field in &fields {
-        field_initializers.push(parse_field(field, struct_name)?);
+        let (initializer, check) = parse_field(field, struct_name)?;
+
+        field_initializers.push(initializer);
+        default_checks.push(check);
     }
 
-    Ok((field_initializers, attributes))
+    Ok((field_initializers, default_checks, attributes))
 }
 
 fn parse_struct_attributes(input: &DeriveInput) -> Result<StructAttributes, String> {
@@ -117,7 +122,7 @@ fn parse_struct_attributes(input: &DeriveInput) -> Result<StructAttributes, Stri
     Ok(attributes)
 }
 
-fn parse_field(field: &Field, struct_name: &Ident) -> Result<TokenStream, String> {
+fn parse_field(field: &Field, struct_name: &Ident) -> Result<(TokenStream, TokenStream), String> {
     let Some(field_name) = field.ident.as_ref() else {
         return Err("expected a field name".to_string());
     };
@@ -129,9 +134,13 @@ fn parse_field(field: &Field, struct_name: &Ident) -> Result<TokenStream, String
         }
     }
 
-    Ok(attributes
+    let default_check = generate_default_check(field_name, &attributes.default_value, &field.ty);
+    let initializer = attributes
         .into_token_stream(field_name, struct_name, &field.ty)
-        .into())
+        .into();
+
+
+    Ok((initializer, default_check))
 }
 
 fn parse_attribute(attr: &Attribute, field_name: &Ident) -> Result<FieldAttributes, String> {
@@ -169,3 +178,30 @@ fn parse_attribute(attr: &Attribute, field_name: &Ident) -> Result<FieldAttribut
         default_value,
     })
 }
+
+fn generate_default_check(field_name: &Ident, default_value: &Option<String>, field_type: &syn::Type) -> TokenStream {
+    let is_option = match field_type {
+        syn::Type::Path(type_path) if type_path.path.segments.len() == 1 => {
+            type_path.path.segments[0].ident == "Option"
+        }
+        _ => false,
+    };
+
+    let check = if let Some(default) = default_value {
+        if is_option {
+            if default == "None" {
+                quote! { self.#field_name.is_none() }
+            } else {
+                quote! { self.#field_name.as_ref().map(|v| v.to_string()) == Some(#default.to_string()) }
+            }
+        } else {
+            quote! { self.#field_name.to_string() == #default }
+        }
+    } else {
+        quote! { false } // No default specified
+    };
+
+    quote! {
+        (stringify!(#field_name), #check)
+    }
+}

mikros/src/definition.rs

@@ -1,6 +1,7 @@
 pub(crate) mod errors;
 pub mod service;
 mod validation;
+mod name;
 
 use std::cmp::PartialEq;
 use std::collections::HashMap;
@@ -11,6 +12,8 @@ use std::sync::Arc;
 use serde::de::DeserializeOwned;
 use validator::ValidateArgs;
 
+use crate::definition::name::ServiceName;
+
 // ServiceInfo represents the service information loaded from the 'service.toml'
 // file.
 #[derive(serde_derive::Deserialize, validator::Validate, Debug)]
@@ -21,7 +24,7 @@ use validator::ValidateArgs;
     use_context
 ))]
 pub struct Definitions {
-    pub name: String,
+    pub name: ServiceName,
     pub version: String,
     pub language: String,
     pub product: String,

mikros/src/definition/name.rs

@@ -0,0 +1,42 @@
+use std::ops::Deref;
+
+#[derive(Debug, Clone, serde_derive::Deserialize)]
+pub struct ServiceName(String);
+
+impl ServiceName {
+    pub fn new(name: &str) -> Self {
+        Self(name.to_string())
+    }
+
+    pub fn to_snake_case(&self) -> String {
+        let mut result = String::new();
+        let mut prev_char: Option<char> = None;
+
+        for (i, c) in self.0.char_indices() {
+            if i > 0 && c.is_uppercase() {
+                if let Some(prev) = prev_char {
+                    if prev != '_' && prev != '-' {
+                        result.push('_');
+                    }
+                }
+            }
+
+            if c == '-' {
+                result.push('_');
+            } else {
+                result.push(c.to_ascii_lowercase());
+            }
+
+            prev_char = Some(c);
+        }
+
+        result
+    }
+}
+
+impl Deref for ServiceName {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}

mikros/src/env.rs

@@ -37,9 +37,13 @@ impl Env {
         let mut env = Env::from_env();
         env.defined_envs = Self::load_defined_envs(defs)?;
 
+        // Get the service name in snake_case to be compatible with environment
+        // variables declaration.
+        let name = defs.name.to_snake_case();
+
         // Load the same values but using the service as suffix to override the
         // previous values.
-        let svc_env = Env::from_env_with_suffix(&defs.name, false);
+        let svc_env = Env::from_env_with_suffix(&name, false);
 
         Ok(Arc::new(env.merge(svc_env)))
     }
@@ -80,23 +84,32 @@ impl Env {
             tracker_header_name: Self::string_other(&other.tracker_header_name, &self.tracker_header_name),
             coupled_namespace: Self::string_other(&other.coupled_namespace, &self.coupled_namespace),
             coupled_port: Self::string_other(&other.coupled_port, &self.coupled_port),
-            grpc_port: other.grpc_port | self.grpc_port,
-            http_port: other.http_port | self.http_port,
+            grpc_port: Self::i32_other(other.grpc_port, self.grpc_port),
+            http_port: Self::i32_other(other.http_port, self.http_port),
             hide_response_fields: other.hide_response_fields.or(self.hide_response_fields),
             defined_envs: self.defined_envs,
         }
     }
 
     fn string_other(a: &str, b: &str) -> String {
-        println!("a:{a}, b:{b}");
-        if !a.is_empty() {
-            return a.to_string()
-        }
+        if !a.is_empty() { a.to_string() } else { b.to_string() }
+    }
 
-        b.to_string()
+    fn i32_other(a: i32, b: i32) -> i32 {
+        if a != 0 { a } else { b }
     }
 }
 
+#[macro_export]
+macro_rules! env_is_default {
+    ($struct:expr, $field:ident) => {{
+        let defaults = $struct.check_defaults();
+        defaults.iter().find(|&&(name, _)| name == stringify!($field))
+            .map(|&(_, is_default)| is_default)
+            .unwrap_or(false)
+    }};
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

mikros/src/service/context.rs

@@ -65,7 +65,7 @@ impl Context {
     /// Returns the current service name.
     #[must_use]
     pub fn service_name(&self) -> String {
-        self.definitions.name.clone()
+        self.definitions.name.to_string()
     }
 
     /// Returns the URL connection string for linking services.

mikros/src/service/grpc.rs

@@ -12,11 +12,11 @@ use tonic::body::BoxBody;
 use tonic::server::NamedService;
 use tonic::transport::Server;
 
-use crate::errors as merrors;
 use crate::grpc;
 use crate::service::context::Context;
 use crate::service::lifecycle::Lifecycle;
 use crate::{definition, env, plugin};
+use crate::{env_is_default, errors as merrors};
 
 #[derive(Clone)]
 pub(crate) struct Grpc<S> {
@@ -110,7 +110,13 @@ where
             Ok(service_type) => {
                 self.port = match service_type.1 {
                     None => envs.grpc_port,
-                    Some(port) => port,
+                    Some(port) => {
+                        if !env_is_default!(envs, grpc_port) {
+                            envs.grpc_port
+                        } else {
+                            port
+                        }
+                    }
                 }
             }
         }

mikros/src/service/http.rs

@@ -15,7 +15,7 @@ use crate::http::ServiceState;
 use crate::plugin::service::ServiceExecutionMode;
 use crate::service::context::Context;
 use crate::service::lifecycle::Lifecycle;
-use crate::{definition, env, errors as merrors, plugin};
+use crate::{definition, env, env_is_default, errors as merrors, plugin};
 
 #[derive(Clone)]
 pub(crate) struct Http {
@@ -141,7 +141,13 @@ impl plugin::service::Service for Http {
             Ok(service_type) => {
                 self.port = match service_type.1 {
                     None => envs.http_port,
-                    Some(port) => port,
+                    Some(port) => {
+                        if !env_is_default!(envs, http_port) {
+                            envs.http_port
+                        } else {
+                            port
+                        }
+                    }
                 }
             }
         }