grpc support + add docs (wip)

Cargo.toml

@@ -56,6 +56,10 @@ log = "0.4.20"
 env_logger = "0.10.0"
 stripmargin = "0.1.1"
 ring = "0.17.5"
+tonic = { version = "0.10.2", features = ["tls"] }
+tonic-reflection = "0.10.2"
+hyper-tls = "0.5.0"
+tokio-stream = "0.1.14"
 
 [dev-dependencies]
 criterion = "0.5.1"

src/blueprint/blueprint.rs

@@ -1,3 +1,6 @@
+/*!
+* define the structure of a blueprint, which could include schema definitions.
+*/
 use std::collections::{BTreeSet, HashMap};
 
 use async_graphql::dynamic::{Schema, SchemaBuilder};

src/blueprint/from_config.rs

@@ -1,3 +1,7 @@
+/*!
+* Parse configurations into an internal representation.
+* transform the application's configuration into a blueprint for the GraphQL schema.
+*/
 #![allow(clippy::too_many_arguments)]
 
 use std::collections::{BTreeMap, BTreeSet, HashMap};
@@ -56,6 +60,8 @@ pub fn config_blueprint<'a>() -> TryFold<'a, Config, Blueprint, String> {
     .update(super::compress::compress)
 }
 
+///  parses and validates the upstream configuration, 
+/// such as the base URL for HTTP connections.
 fn to_upstream<'a>() -> TryFold<'a, Config, Upstream, String> {
   TryFoldConfig::<Upstream>::new(|config, up| {
     let upstream = up.merge_right(config.upstream.clone());
@@ -82,6 +88,8 @@ pub fn apply_batching(mut blueprint: Blueprint) -> Blueprint {
   blueprint
 }
 
+///  converts GraphQL directives from the configuration 
+/// into a valid Directive structure that can be used by the application.
 fn to_directive(const_directive: ConstDirective) -> Valid<Directive, String> {
   const_directive
     .arguments
@@ -99,6 +107,8 @@ fn to_directive(const_directive: ConstDirective) -> Valid<Directive, String> {
     .into()
 }
 
+/// transforms the GraphQL schema configuration into a SchemaDefinition, 
+/// validating the presence of the query root and handling server directives.
 fn to_schema<'a>() -> TryFoldConfig<'a, SchemaDefinition> {
   TryFoldConfig::new(|config, _| {
     validate_query(config)
@@ -111,7 +121,7 @@ fn to_schema<'a>() -> TryFoldConfig<'a, SchemaDefinition> {
       .map(|(query_type_name, directive)| SchemaDefinition {
         query: query_type_name.to_owned(),
         mutation: config.graphql.schema.mutation.clone(),
-        directives: vec![directive],
+        directives: vec![directive], //TODO: should check support grpc directive!
       })
   })
 }

src/blueprint/into_schema.rs

@@ -1,3 +1,8 @@
+/*!
+ *
+ * This module is responsible for converting configuration into a GraphQL schema.
+ *
+*/
 use std::borrow::Cow;
 use std::sync::Arc;
 

src/blueprint/server.rs

@@ -1,3 +1,6 @@
+/*!
+* relate to server configuration or server-specific aspects of the blueprint.
+*/
 use std::collections::BTreeMap;
 use std::net::{AddrParseError, IpAddr};
 

src/grpc/mod.rs

@@ -0,0 +1 @@
+pub mod reflection_client;

src/grpc/reflection_client.rs

@@ -0,0 +1,90 @@
+use hyper::http::uri::InvalidUri;
+use hyper_tls::HttpsConnector;
+use tonic::transport::{Certificate, Channel, ClientTlsConfig, Endpoint, Identity};
+use tokio_stream::StreamExt;
+use tonic_reflection::pb::{
+  server_reflection_client::ServerReflectionClient, server_reflection_request, server_reflection_response,
+  ListServiceResponse, ServerReflectionRequest,
+};
+
+/// Fetch service name and method name from a given grpc server dynamically
+pub async fn fetch_service_schema(
+  address: &str,
+  service_name: &str,
+  /*tls_config: Option<(String, Identity)>*/
+) -> Result<Vec<String>, tonic::Status> {
+  let https = HttpsConnector::new();
+  let channel = match Channel::builder(
+    address
+      .parse()
+      .map_err(|e: InvalidUri| tonic::Status::internal(e.to_string()))?,
+  )
+  .connect_with_connector(https)
+  .await
+  {
+    Ok(it) => it,
+    Err(err) => return Err(tonic::Status::internal(format!("Transport error: {}", err))),
+  };
+  // let channel = setup_channel(address, tls_config);
+
+  let mut client = ServerReflectionClient::new(channel);
+
+  let request = ServerReflectionRequest {
+    host: "".into(),
+    message_request: Some(server_reflection_request::MessageRequest::ListServices("".into())),
+    ..Default::default()
+  };
+
+  let response = client
+    .server_reflection_info(tonic::Request::new(tokio_stream::once(request)))
+    .await?;
+
+  let mut response_stream = response.into_inner();
+
+  let mut services = Vec::new();
+
+  while let Some(result) = response_stream.next().await {
+    match result {
+      Ok(resp) => {
+        if let Some(msg_resp) = resp.message_response {
+          match msg_resp {
+            server_reflection_response::MessageResponse::ListServicesResponse(ListServiceResponse {
+              service: inner_services,
+            }) => {
+              for service in inner_services {
+                services.push(service.name);
+              }
+            }
+            _ => {}
+          }
+        }
+      }
+      Err(e) => {
+        eprintln!("Error fetching service schema: {}", e);
+      }
+    }
+  }
+
+  // Filter the services based on the provided service_name
+  services = services.into_iter().filter(|name| name == service_name).collect();
+
+  Ok(services)
+}
+
+//TODO: move this to utils, may change function signature! - util fns
+pub async fn setup_channel(address: &str, tls_config: Option<(String, Identity)>) -> Result<Channel, tonic::Status> {
+  let mut endpoint = Endpoint::from_shared(address.to_string()).map_err(|e| tonic::Status::internal(e.to_string()))?;
+
+  if let Some((cert, identity)) = tls_config {
+    let cert = Certificate::from_pem(cert);
+    endpoint = endpoint.tls_config(ClientTlsConfig::new().identity(identity).ca_certificate(cert))
+    .map_err(|e| tonic::Status::internal(e.to_string()))?;
+  }
+
+  let channel = endpoint
+    .connect()
+    .await
+    .map_err(|err| tonic::Status::internal(format!("Transport error: {}", err)))?;
+
+  Ok(channel)
+}

src/lib.rs

@@ -9,6 +9,8 @@ pub mod document;
 pub mod endpoint;
 pub mod has_headers;
 pub mod http;
+pub mod grpc; 
+
 #[cfg(feature = "unsafe-js")]
 pub mod javascript;
 pub mod json;