fix: structure

Cargo.toml

@@ -1,3 +1,3 @@
 [workspace]
-members = ["src/public", "src/grpc_server"]
+members = ["src/public", "src/gpt_answer_server"]
 resolver = "2"

src/adapter/Cargo.toml

@@ -12,8 +12,14 @@ autoexamples = true
 autotests = true
 autobenches = true
 
-[dependencies]
-diesel_migrations = "2.1.0"
+[dependencies.rust_core]
+path = "../core"
+
+[dependencies.common]
+path = "../common"
+
+[dependencies.diesel_migrations]
+version = "2.1.0"
 
 [dependencies.async-trait]
 version = "0.1.77"
@@ -26,9 +32,6 @@ features = ["postgres", "serde"]
 version = "2.1.4"
 features = ["postgres", "postgres_backend", "uuid"]
 
-[dependencies.rust_core]
-path = "../core"
-
 [dependencies.serde]
 version = "1.0"
 features = ["derive"]
@@ -46,6 +49,3 @@ version = "1.0.80"
 
 [dependencies.tonic]
 version = "0.11.0"
-
-[dependencies.grpc_interface]
-path = "../grpc"

src/adapter/src/repositories/grpc/gpt_answer_client.rs

@@ -0,0 +1,103 @@
+use anyhow::Error;
+use tonic::{
+    async_trait,
+    transport::{Channel, Endpoint},
+};
+
+use common::grpc::gpt_answer::gpt_answer::{
+    gpt_answer_service_client::GptAnswerServiceClient, GetAnswerPayload,
+};
+use rust_core::{common::errors::CoreError, ports::gpt_answer::GptAnswerPort};
+
+/// gRPC client for interacting with a GPT (Generative Pre-trained Transformer) answer service.
+///
+/// This struct represents a client for making gRPC calls to a GPT answer service. It provides
+/// methods for connecting to the service, sending a question, and receiving an answer.
+#[derive(Clone)]
+pub struct GptAnswerClient {
+    client: Option<GptAnswerServiceClient<Channel>>,
+    endpoint: Endpoint,
+}
+
+impl GptAnswerClient {
+    /// Creates a new `GptAnswerClient` instance with the provided gRPC endpoint.
+    ///
+    /// # Arguments
+    ///
+    /// * `endpoint`: An `Endpoint` representing the gRPC communication endpoint.
+    ///
+    /// # Returns
+    ///
+    /// Returns a new instance of `GptAnswerClient`.
+    fn new(endpoint: Endpoint) -> Self {
+        Self {
+            client: None,
+            endpoint,
+        }
+    }
+
+    /// Initializes a new `GptAnswerClient` instance with the provided URI.
+    ///
+    /// # Arguments
+    ///
+    /// * `uri`: A `String` representing the URI of the GPT answer service.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `Result` containing the initialized `GptAnswerClient` if successful,
+    /// or a `CoreError` if an error occurs during initialization.
+    pub async fn init(uri: String) -> Result<Self, CoreError> {
+        // Establish connection to the gRPC server
+        let endpoint =
+            Channel::from_shared(uri).map_err(|err| CoreError::InternalError(err.into()))?;
+
+        Ok(Self::new(endpoint))
+    }
+
+    /// Establishes a connection to the GPT answer service at the specified URI.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `Result` containing the connected `GptAnswerServiceClient` if successful,
+    /// or a `CoreError` if an error occurs during connection.
+    pub async fn connect(&mut self) -> Result<(), CoreError> {
+        let client = GptAnswerServiceClient::connect(self.endpoint.clone())
+            .await
+            .map_err(|err| CoreError::InternalError(err.into()))?;
+
+        self.client = Some(client);
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl GptAnswerPort for GptAnswerClient {
+    /// Sends a question to the GPT answer service and retrieves the generated answer.
+    ///
+    /// # Arguments
+    ///
+    /// * `question`: A `&str` representing the question to be sent to the service.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `Result` containing the generated answer as a `String` if successful,
+    /// or a `CoreError` if an error occurs during communication with the service.
+    async fn get_answer(&self, question: &str) -> Result<String, CoreError> {
+        let client = self
+            .client
+            .as_ref()
+            .ok_or_else(|| CoreError::InternalError(Error::msg("Client not initialized")))?;
+
+        let request = tonic::Request::new(GetAnswerPayload {
+            question: question.to_string(),
+        });
+
+        let response = client
+            .clone()
+            .get_answer(request)
+            .await
+            .map_err(|err| CoreError::InternalError(err.into()))?;
+
+        Ok(response.into_inner().answer)
+    }
+}

src/adapter/src/repositories/grpc/mod.rs

@@ -1,2 +1 @@
-pub mod config;
-pub mod models;
+pub mod gpt_answer_client;

src/adapter/src/repositories/postgres/models/question.rs

@@ -1,12 +1,11 @@
-use std::{
-    io::{Error, ErrorKind},
-    time::SystemTime,
-};
+use std::io::{Error, ErrorKind};
+use std::time::SystemTime;
 
 use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
-use rust_core::entities::question::{QuestionEntity, QuestionId};
 use serde::Serialize;
 
+use rust_core::entities::question::{QuestionEntity, QuestionId};
+
 #[derive(Debug, Queryable, Serialize, Selectable, Insertable, AsChangeset, Identifiable)]
 #[diesel(table_name = super::super::schema::questions)]
 #[cfg_attr(feature = "postgres", derive(diesel::pg::Pg))]

src/adapter/src/repositories/postgres/question_db.rs

@@ -37,14 +37,14 @@ impl QuestionPort for QuestionDBRepository {
             .await
             .unwrap()
             .interact(move |conn| {
-                let question =
-                    QuestionModel::try_from(question).map_err(|_| CoreError::InternalError)?;
+                let question = QuestionModel::try_from(question)
+                    .map_err(|err| CoreError::InternalError(err.into()))?;
                 let response = insert_into(questions)
                     .values(&question)
                     .get_result::<QuestionModel>(conn)
                     .map_err(|err| match err {
                         diesel::result::Error::NotFound => CoreError::NotFound,
-                        _ => CoreError::InternalError,
+                        _ => CoreError::InternalError(err.into()),
                     })
                     .unwrap();
                 Ok(response.into())
@@ -59,14 +59,14 @@ impl QuestionPort for QuestionDBRepository {
             .await
             .unwrap()
             .interact(move |conn| {
-                let question =
-                    QuestionModel::try_from(question).map_err(|_| CoreError::InternalError)?;
+                let question = QuestionModel::try_from(question)
+                    .map_err(|err| CoreError::InternalError(err.into()))?;
                 let response = update(questions.filter(id.eq(question.id)))
                     .set(&question)
                     .get_result::<QuestionModel>(conn)
                     .map_err(|err| match err {
                         diesel::result::Error::NotFound => CoreError::NotFound,
-                        _ => CoreError::InternalError,
+                        _ => CoreError::InternalError(err.into()),
                     })?
                     .into();
 
@@ -87,7 +87,7 @@ impl QuestionPort for QuestionDBRepository {
                     .execute(conn)
                     .map_err(|err| match err {
                         diesel::result::Error::NotFound => CoreError::NotFound,
-                        _ => CoreError::InternalError,
+                        _ => CoreError::InternalError(err.into()),
                     })?;
 
                 Ok(())
@@ -109,7 +109,7 @@ impl QuestionPort for QuestionDBRepository {
                     .first(conn)
                     .map_err(|err| match err {
                         diesel::result::Error::NotFound => CoreError::NotFound,
-                        _ => CoreError::InternalError,
+                        _ => CoreError::InternalError(err.into()),
                     })?
                     .into();
 
@@ -133,7 +133,7 @@ impl QuestionPort for QuestionDBRepository {
                     .load(conn)
                     .map_err(|err| match err {
                         diesel::result::Error::NotFound => CoreError::NotFound,
-                        _ => CoreError::InternalError,
+                        _ => CoreError::InternalError(err.into()),
                     })?;
 
                 Ok(question_list

src/adapter/src/repositories/repository_test.rs

@@ -51,7 +51,7 @@ mod tests {
         query_params.insert("start".to_string(), "0".to_string());
         query_params.insert("end".to_string(), "10".to_string());
 
-        let pagination = match PaginationEntity::from_query(&query_params) {
+        let pagination = match PaginationEntity::try_from(query_params) {
             Ok(pagination_entity) => pagination_entity,
             Err(err) => {
                 panic!("Failed to parse pagination entity: {:?}", err);

src/common/Cargo.toml

@@ -11,12 +11,20 @@ autoexamples = true
 autotests = true
 autobenches = true
 
-[dependencies]
-config = "0.14.0"
-glob = "0.3.1"
-tracing = "0.1"
-tracing-bunyan-formatter = "0.3.9"
-tracing-opentelemetry = "0.23.0"
+[dependencies.config]
+version = "0.14.0"
+
+[dependencies.glob]
+version = "0.3.1"
+
+[dependencies.tracing]
+version = "0.1"
+
+[dependencies.tracing-bunyan-formatter]
+version = "0.3.9"
+
+[dependencies.tracing-opentelemetry]
+version = "0.23.0"
 
 [dependencies.opentelemetry]
 version = "0.22.0"
@@ -39,3 +47,15 @@ features = ["derive"]
 [dependencies.tracing-subscriber]
 version = "0.3.18"
 features = ["env-filter"]
+
+[dependencies.tonic]
+version = "0.11.0"
+
+[dependencies.prost]
+version = "0.12.3"
+
+[build-dependencies.tonic-build]
+version = "0.11.0"
+
+[build-dependencies.glob]
+version = "0.3.1"

src/common/src/grpc/gpt_answer.rs

@@ -0,0 +1,9 @@
+/// Module for gRPC service definitions related to answering questions with GPT (Generative Pre-trained Transformer) models.
+///
+/// This module includes generated gRPC service definitions for answering questions using GPT models.
+/// The `tonic::include_proto!` macro is used to include the protobuf definitions, enabling easy
+/// integration of gRPC services into Rust code.
+pub mod gpt_answer {
+    // Include the protobuf definitions for the gpt_answer service.
+    tonic::include_proto!("gpt_answer");
+}

src/common/src/lib.rs

@@ -1,2 +1,3 @@
+pub mod grpc;
 pub mod loggers;
 pub mod options;

src/core/Cargo.toml

@@ -22,5 +22,5 @@ features = ["derive"]
 [dependencies.thiserror]
 version = "1.0.57"
 
-[dependencies]
-anyhow = "1.0.80"
+[dependencies.anyhow]
+version = "1.0.80"

src/core/src/common/errors.rs

@@ -1,3 +1,5 @@
+use anyhow::Error;
+
 #[derive(thiserror::Error, Debug)]
 pub enum CoreError {
     #[error("parse error {0}")]
@@ -8,10 +10,10 @@ pub enum CoreError {
 
     #[error("missing parameters")]
     MissingParameters,
+
     #[error("not found")]
     NotFound,
-    #[error("transparent")]
-    InternalError,
-    #[error("unknown data store error")]
-    Unknown,
+
+    #[error("internal error {0}")]
+    InternalError(#[from] Error),
 }