apibrasil 1.0.0

//! Macros internos que declaram os serviços da SDK a partir de uma
//! tabela de rotas — as rotas device-based e as consultas por crédito são
//! perfeitamente uniformes, então descrevê-las é mais claro (e menos
//! sujeito a divergência) do que repetir o mesmo corpo em cada método.

/// Declara um serviço *device-based* (`POST /{servico}/{action}`) e os
/// seus métodos nomeados.
macro_rules! device_service {
    (
        $(#[$meta:meta])*
        $name:ident($service:literal) {
            $(
                $(#[$method_meta:meta])*
                $method:ident => $action:literal
            ),* $(,)?
        }
    ) => {
        $(#[$meta])*
        ///
        /// Além dos métodos nomeados,
        /// [`request`](crate::services::DeviceProxyService::request) aceita
        /// qualquer action do catálogo e
        /// [`queue`](crate::services::DeviceProxyService::queue) executa a
        /// mesma action por fila.
        #[derive(Clone, Debug)]
        pub struct $name {
            base: $crate::services::DeviceProxyService,
        }

        impl $name {
            /// Serviço do gateway coberto por este módulo.
            pub const SERVICE: &'static str = $service;

            pub(crate) fn new(client: ::std::sync::Arc<$crate::core::HttpClient>) -> Self {
                Self {
                    base: $crate::services::DeviceProxyService::new(client, $service),
                }
            }

            /// Devolve uma cópia do serviço que usa `options` em todas as
            /// chamadas.
            pub fn with_options(&self, options: $crate::core::RequestOptions) -> Self {
                Self { base: self.base.with_options(options) }
            }

            $(
                $(#[$method_meta])*
                pub async fn $method(
                    &self,
                    body: impl $crate::core::IntoBody,
                ) -> $crate::core::Result<$crate::core::DeviceResponse> {
                    self.base.request($action, body).await
                }
            )*
        }

        impl ::std::ops::Deref for $name {
            type Target = $crate::services::DeviceProxyService;

            fn deref(&self) -> &Self::Target {
                &self.base
            }
        }
    };
}

/// Declara os métodos nomeados de uma consulta por crédito
/// (`POST /consulta/{servico}/credits`).
macro_rules! credit_methods {
    (
        $name:ident {
            $(
                $(#[$method_meta:meta])*
                $method:ident => $service:literal
            ),* $(,)?
        }
    ) => {
        impl $name {
            $(
                $(#[$method_meta])*
                pub async fn $method(
                    &self,
                    body: impl $crate::core::IntoBody,
                ) -> $crate::core::Result<$crate::core::CreditResponse> {
                    self.base.request($service, body).await
                }
            )*
        }
    };
}

/// Declara um serviço da plataforma sobre [`BaseService`](crate::services::BaseService).
macro_rules! platform_service {
    (
        $(#[$meta:meta])*
        $name:ident
    ) => {
        $(#[$meta])*
        #[derive(Clone, Debug)]
        pub struct $name {
            base: $crate::services::BaseService,
        }

        impl $name {
            pub(crate) fn new(client: ::std::sync::Arc<$crate::core::HttpClient>) -> Self {
                Self { base: $crate::services::BaseService::new(client) }
            }

            /// Devolve uma cópia do serviço que usa `options` em todas as
            /// chamadas.
            pub fn with_options(&self, options: $crate::core::RequestOptions) -> Self {
                Self { base: self.base.with_options(options) }
            }
        }

        impl ::std::ops::Deref for $name {
            type Target = $crate::services::BaseService;

            fn deref(&self) -> &Self::Target {
                &self.base
            }
        }
    };
}

/// Declara métodos `GET path` sem parâmetros que devolvem [`Json`](crate::Json).
macro_rules! json_get {
    (
        $name:ident {
            $(
                $(#[$method_meta:meta])*
                $method:ident => $path:literal
            ),* $(,)?
        }
    ) => {
        impl $name {
            $(
                $(#[$method_meta])*
                pub async fn $method(&self) -> $crate::core::Result<$crate::core::Json> {
                    self.base.get($path).await
                }
            )*
        }
    };
}

/// Declara métodos que enviam um body e devolvem [`Json`](crate::Json).
macro_rules! json_body {
    (
        $name:ident {
            $(
                $(#[$method_meta:meta])*
                $method:ident => $verb:ident $path:literal
            ),* $(,)?
        }
    ) => {
        impl $name {
            $(
                $(#[$method_meta])*
                pub async fn $method(
                    &self,
                    body: impl $crate::core::IntoBody,
                ) -> $crate::core::Result<$crate::core::Json> {
                    self.base.$verb($path, body).await
                }
            )*
        }
    };
}

/// Declara métodos sem parâmetros que enviam uma requisição sem body.
macro_rules! json_empty {
    (
        $name:ident {
            $(
                $(#[$method_meta:meta])*
                $method:ident => $verb:ident $path:literal
            ),* $(,)?
        }
    ) => {
        impl $name {
            $(
                $(#[$method_meta])*
                pub async fn $method(&self) -> $crate::core::Result<$crate::core::Json> {
                    self.base.$verb($path, None).await
                }
            )*
        }
    };
}