Feat: Adding 'error_logging: bool (default: true)' optional parameter on the make_operation macro, when the 'log' feature is enabled. The parameter governs weither or not the execute_operation method should log::error!({e}) on a AppsyncError response before turning it into the opaque AppsyncResponse type

Author: JeremieRodon

lambda-appsync-proc/src/internal/make_appsync/graphql.rs

@@ -6,6 +6,8 @@ use quote::{quote, quote_spanned, ToTokens};
 use syn::Path;
 use syn::{spanned::Spanned, LitStr};
 
+use crate::internal::make_appsync::MakeOperationParameters;
+
 use super::super::common::{Name, OperationKind};
 use super::overrides::{
     FieldTypeOverride, FieldTypeOverrides, OverrideParameters, TypeNameOverride, TypeOverride,
@@ -776,12 +778,13 @@ pub(super) struct GraphQLSchema {
     subscriptions: Operations,
     structures: Vec<Structure>,
     enums: Vec<Enum>,
+    make_operation_parameters: Option<MakeOperationParameters>,
 }
 impl GraphQLSchema {
     pub(super) fn new(
         graphql_schema_path: LitStr,
         override_parameters: OverrideParameters,
-        custom_type_module: Option<Path>,
+        make_operation_parameters: Option<MakeOperationParameters>,
     ) -> Result<Self, syn::Error> {
         let mut queries = None;
         let mut mutations = None;
@@ -853,7 +856,11 @@ impl GraphQLSchema {
                                 // This is an Object defining operations
                                 let type_overrides = type_overrides.remove(&object_type.name);
                                 let mut ops = Operations::from(object_type);
-                                if let Some(ref custom_type_module) = custom_type_module {
+                                if let Some(MakeOperationParameters {
+                                    type_module: Some(ref custom_type_module),
+                                    ..
+                                }) = make_operation_parameters
+                                {
                                     ops.apply_type_module_path(custom_type_module);
                                 }
                                 if let Some(type_overrides) = type_overrides {
@@ -992,6 +999,7 @@ impl GraphQLSchema {
                 subscriptions: subscriptions.unwrap_or_default(),
                 structures,
                 enums,
+                make_operation_parameters,
             })
         } else {
             Err(errors
@@ -1082,9 +1090,15 @@ impl GraphQLSchema {
         #[allow(unused_mut)]
         let mut log_lines = proc_macro2::TokenStream::new();
         #[cfg(feature = "log")]
-        log_lines.extend(quote_spanned! {span=>
-            ::lambda_appsync::log::error!("{e}");
-        });
+        if self
+            .make_operation_parameters
+            .as_ref()
+            .is_some_and(|p| p.error_logging)
+        {
+            log_lines.extend(quote_spanned! {span=>
+                ::lambda_appsync::log::error!("{e}");
+            });
+        }
 
         tokens.extend(quote_spanned! {span=>
             impl Operation {

lambda-appsync-proc/src/internal/make_appsync/make_operation.rs

@@ -1,5 +1,7 @@
 use proc_macro2::TokenStream as TokenStream2;
 use quote::ToTokens;
+#[cfg(feature = "log")]
+use syn::LitBool;
 use syn::{
     parse::{Parse, ParseStream},
     parse_macro_input, LitStr, Path, Result, Token,
@@ -12,27 +14,44 @@ use super::{
 
 pub(super) enum MakeOperationParameter {
     TypeModule(Path),
+    #[cfg(feature = "log")]
+    ErrorLogging(bool),
 }
 impl OptionalParameter for MakeOperationParameter {
     fn try_parse_parameter(input: ParseStream) -> core::result::Result<Self, ParameterError> {
         let ident = Self::parse_ident(input)?;
         #[allow(clippy::match_single_binding)]
         match ident.to_string().as_str() {
             "type_module" => Ok(Self::TypeModule(input.parse()?)),
+            #[cfg(feature = "log")]
+            "error_logging" => Ok(Self::ErrorLogging(input.parse::<LitBool>()?.value())),
             // Unknown option
             _ => ident.unknown(),
         }
     }
 }
 
-#[derive(Default)]
 pub(super) struct MakeOperationParameters {
-    type_module: Option<Path>,
+    pub(super) type_module: Option<Path>,
+    #[cfg(feature = "log")]
+    pub(super) error_logging: bool,
+}
+impl Default for MakeOperationParameters {
+    fn default() -> Self {
+        Self {
+            type_module: None,
+            error_logging: true,
+        }
+    }
 }
 impl OptionalParameters<MakeOperationParameter> for MakeOperationParameters {
     fn set_param(&mut self, p: MakeOperationParameter) {
         match p {
             MakeOperationParameter::TypeModule(path) => self.type_module = Some(path),
+            #[cfg(feature = "log")]
+            MakeOperationParameter::ErrorLogging(error_logging) => {
+                self.error_logging = error_logging
+            }
         }
     }
 }
@@ -69,11 +88,8 @@ impl Parse for MakeOperation {
             parameters.try_parse_parameter(input)?;
         }
 
-        let graphql_schema = GraphQLSchema::new(
-            graphql_schema_path,
-            override_parameters,
-            parameters.type_module,
-        )?;
+        let graphql_schema =
+            GraphQLSchema::new(graphql_schema_path, override_parameters, Some(parameters))?;
 
         Ok(Self { graphql_schema })
     }