fix(all): Organizing APIs and docs.

Author: rodrigorodriguez

Cargo.lock

@@ -4,6 +4,7 @@ members = [
     "gb-core",           # Core domain models and traits
     "gb-api",            # API layer and server implementation
     "gb-media",          # Media processing and WebRTC handling
+
     "gb-messaging",      # Message queue and real-time communication
     "gb-storage",        # Database and storage implementations
     "gb-monitoring",     # Metrics, logging and monitoring

Cargo.toml

@@ -265,6 +265,23 @@ Licensed under terms specified in workspace configuration.
 - Annual penetration testing
 - Bi-annual disaster recovery testing
 
----
+
+### **Key Open Source Tools in Rust/Go**:
+1. **Zitadel (Go)**: Identity and access management for secure authentication.
+2. **Stalwart (Rust)**: Secure email server for threat detection.
+3. **MinIO (Go)**: High-performance object storage for unstructured data.
+4. **Ubuntu Advantage (Go/Rust tools)**: Compliance and security tools for Ubuntu.
+5. **Tantivy (Rust)**: Full-text search engine for data discovery.
+6. **Drone (Go)**: CI/CD platform for DevOps automation.
+7. **Temporal (Go)**: Workflow orchestration engine.
+8. **Caddy (Go)**: Web server for seamless customer experiences.
+9. **SeaweedFS (Go)**: Distributed file system for secure file sharing.
+10. **Vector (Rust)**: Observability pipeline for monitoring.
+11. **Tyk (Go)**: API gateway for secure API management.
+12. **Vault (Go)**: Secrets management and encryption.
+13. **Hugging Face Transformers (Rust/Go bindings)**: LLM integration and fine-tuning.
+14. **Kubernetes (Go)**: Container orchestration for scalable deployments.
+15. **Matrix (Rust)**: Real-time communication and collaboration.
+
 
 Built with ❤️ from Brazil, using Rust for maximum performance and reliability.

README.md

@@ -3,6 +3,17 @@ use tracing::{info, error};
 use std::net::SocketAddr;
 use gb_messaging::MessageProcessor;
 
+
+#[allow(dead_code)]
+#[derive(Clone)]
+struct AppState {
+    db: sqlx::PgPool,
+    redis: redis::Client,
+    message_processor: MessageProcessor,
+    customer: PostgresCustomerRepository,
+
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
     // Initialize logging first
@@ -20,9 +31,12 @@ async fn initialize_bot_server() -> Result<axum::Router> {
 
     // Initialize the MessageProcessor
     let message_processor = MessageProcessor::new();
-    
+    let state = AppState::new();
+    state.repo = PostgresCustomerRepository::new(Arc::new(pool));
+   
+
     // Build the Axum router using our router module
-    let app = gb_api::create_router(message_processor)
+    let app = gb_api::create_router(state)
         .layer(tower_http::trace::TraceLayer::new_for_http());
 
     Ok(app)
@@ -61,12 +75,6 @@ async fn initialize_redis() -> Result<redis::Client> {
         .map_err(|e| Error::internal(e.to_string()))
 }
 
-#[allow(dead_code)]
-#[derive(Clone)]
-struct AppState {
-    db: sqlx::PgPool,
-    redis: redis::Client,
-}
 
 
 async fn start_server(app: axum::Router) -> Result<()> {

gb-api/src/main.rs

@@ -0,0 +1,20 @@
+[package]
+name = "gb-calendar"
+version = { workspace = true }
+edition = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+
+[dependencies]
+gb-core = { path = "../gb-core" }
+async-trait= { workspace = true }
+tokio= { workspace = true }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"thiserror= { workspace = true }
+tracing= { workspace = true }
+minio-rs = "0.1"
+
+[dev-dependencies]
+rstest= { workspace = true }
+tokio-test = "0.4"
+tempfile = "3.8"

gb-calendar/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "gb-document"
+name = "gb-file"
 version = { workspace = true }
 edition = { workspace = true }
 authors = { workspace = true }
@@ -10,9 +10,10 @@ gb-core = { path = "../gb-core" }
 async-trait= { workspace = true }
 tokio= { workspace = true }
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"thiserror= { workspace = true }
+serde_json = "1.0"
+thiserror= { workspace = true }
 tracing= { workspace = true }
-minio-rs = "0.1"
+minio = "0.1.0"
 
 [dev-dependencies]
 rstest= { workspace = true }

gb-file/src/facade.rs renamed to gb-calendar/src/lib.rs

@@ -0,0 +1,144 @@
+use minio::s3::client::Client;
+use minio::s3::args::{BucketExistsArgs, MakeBucketArgs, RemoveObjectArgs, GetObjectArgs, PutObjectArgs, ListObjectsArgs};
+use minio::s3::creds::StaticProvider;
+use minio::s3::error::Error as MinioError;
+use minio::s3::types::{BaseUrl, Item};
+use std::io::Cursor;
+use std::path::Path;
+
+pub struct FileManager {
+    client: Client,
+    bucket_name: String,
+}
+
+impl FileManager {
+    pub async fn new(endpoint: &str, access_key: &str, secret_key: &str, bucket_name: &str, use_ssl: bool) -> Result<Self, MinioError> {
+        // Create BaseUrl from endpoint
+        let base_url = BaseUrl::from_string(endpoint)?;
+     let static_provider = StaticProvider::new(
+         access_key,
+         secret_key,
+         None,
+     );
+     let client = Client::new(base_url.clone(), Some(Box::new(static_provider)), None, None).unwrap();
+
+        
+        Ok(Self {
+            client,
+            bucket_name: bucket_name.to_string(),
+        })
+    }
+
+    pub async fn ensure_bucket_exists(&self) -> Result<(), MinioError> {
+        let exists = self.client
+            .bucket_exists(&BucketExistsArgs::new(&self.bucket_name)?)
+            .await?;
+        if !exists {
+            self.client
+                .make_bucket(&MakeBucketArgs::new(&self.bucket_name)?)
+                .await?;
+        }
+        Ok(())
+    }
+
+    pub async fn upload_file(&self, path: &str, file_data: Vec<u8>) -> Result<(), MinioError> {
+        let reader = Cursor::new(&file_data);
+        let file_size = file_data.len() as u64;
+        
+        let args = PutObjectArgs::new(
+            &self.bucket_name,
+            path,
+            reader,
+            Some(file_size),
+            None
+        )?;
+        
+        self.client.put_object(&args).await?;
+        Ok(())
+    }
+
+    pub async fn download_file(&self, path: &str) -> Result<Vec<u8>, MinioError> {
+        let args = GetObjectArgs::new(&self.bucket_name, path)?;
+        let object = self.client.get_object(&args).await?;
+        let data = object.bytes().await?;
+        Ok(data.to_vec())
+    }
+
+    pub async fn copy_file(&self, source_path: &str, destination_path: &str) -> Result<(), MinioError> {
+        // Download the source file
+        let data = self.download_file(source_path).await?;
+        
+        // Upload it to the destination
+        let reader = Cursor::new(&data);
+        let file_size = data.len() as u64;
+        
+        let args = PutObjectArgs::new(
+            &self.bucket_name,
+            destination_path,
+            reader,
+            Some(file_size),
+            None
+        )?;
+        
+        self.client.put_object(&args).await?;
+        Ok(())
+    }
+
+    pub async fn move_file(&self, source_path: &str, destination_path: &str) -> Result<(), MinioError> {
+        self.copy_file(source_path, destination_path).await?;
+        self.delete_file(source_path).await?;
+        Ok(())
+    }
+
+    pub async fn delete_file(&self, path: &str) -> Result<(), MinioError> {
+        let args = RemoveObjectArgs::new(&self.bucket_name, path)?;
+        self.client.remove_object(&args).await?;
+        Ok(())
+    }
+
+    pub async fn list_files(&self, prefix: &str) -> Result<Vec<String>, MinioError> {
+        // Create a predicate function that always returns true
+        let predicate = |_: Vec<Item>| -> bool { true };
+        
+        let args = ListObjectsArgs::new(&self.bucket_name, &predicate)?;
+        let objects = self.client.list_objects(&args).await?;
+        
+        // Filter objects based on prefix manually
+        let file_names: Vec<String> = objects
+            .into_iter()
+            .filter(|obj| obj.name().starts_with(prefix))
+            .map(|obj| obj.name().to_string())
+            .collect();
+            
+        Ok(file_names)
+    }
+
+    pub async fn get_file_contents(&self, path: &str) -> Result<String, MinioError> {
+        let data = self.download_file(path).await?;
+        let contents = String::from_utf8(data)
+            .map_err(|_| MinioError::InvalidResponse(400, "Invalid UTF-8 sequence".to_string()))?;
+        Ok(contents)
+    }
+
+    pub async fn create_folder(&self, path: &str) -> Result<(), MinioError> {
+        let folder_path = if path.ends_with('/') {
+            path.to_string()
+        } else {
+            format!("{}/", path)
+        };
+        
+        // Create empty file with folder path
+        self.upload_file(&folder_path, vec![]).await
+    }
+
+    pub async fn share_folder(&self, path: &str) -> Result<String, MinioError> {
+        // This is just a placeholder implementation
+        Ok(format!("Folder shared: {}", path))
+    }
+
+    pub async fn search_files(&self, prefix: &str, query: &str) -> Result<Vec<String>, MinioError> {
+        let files = self.list_files(prefix).await?;
+        let results = files.into_iter().filter(|f| f.contains(query)).collect();
+        Ok(results)
+    }
+}

gb-file/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "gb-llm"
+version = { workspace = true }
+edition = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+
+[dependencies]
+gb-core = { path = "../gb-core" }
+async-trait= { workspace = true }
+tokio= { workspace = true }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"thiserror= { workspace = true }
+tracing= { workspace = true }
+minio-rs = "0.1"
+
+[dev-dependencies]
+rstest= { workspace = true }
+tokio-test = "0.4"
+tempfile = "3.8"