Updating readme

Author: winrid

README.md

@@ -1,18 +1,225 @@
-# fastcomments-rust
+# FastComments Rust SDK
 
-Fastcomments Rust SDK
+The official Rust SDK for FastComments, a fast and developer-friendly commenting platform. This SDK provides typed API clients and utilities for integrating FastComments into your Rust applications.
 
-# Usage
-
-## Client
+## Installation
 
 ```bash
-cargo add fastcomments-client
+cargo add fastcomments-sdk
 ```
 
-## Core
+The SDK requires Rust 2021 edition or later.
 
-```bash
-cargo add fastcomments-core
+## Library Contents
+
+The FastComments Rust SDK consists of several modules:
+
+- **Client Module** - Auto-generated API client for FastComments REST APIs
+  - Complete type definitions for all API models
+  - Both authenticated (`DefaultApi`) and public (`PublicApi`) endpoints
+  - Full async/await support with tokio
+  - See [client/README.md](client/README.md) for detailed API documentation
+
+- **SSO Module** - Server-side Single Sign-On utilities
+  - Secure token generation for user authentication
+  - Support for both simple and secure SSO modes
+  - HMAC-SHA256 based token signing
+
+- **Core Types** - Shared type definitions and utilities
+  - Comment models and metadata structures
+  - User and tenant configurations
+  - Helper functions for common operations
+
+## Quick Start
+
+### Using the Public API
+
+```rust
+use fastcomments_sdk::client::apis::configuration::Configuration;
+use fastcomments_sdk::client::apis::public_api;
+
+#[tokio::main]
+async fn main() {
+    // Create API configuration
+    let config = Configuration::new();
+
+    // Fetch comments for a page
+    let result = public_api::get_comments_public(
+        &config,
+        public_api::GetCommentsPublicParams {
+            tenant_id: "your-tenant-id".to_string(),
+            urlid: Some("page-url-id".to_string()),
+            url: None,
+            count_only: None,
+            skip: None,
+            limit: None,
+            sort_dir: None,
+            page: None,
+            sso_hash: None,
+            simple_sso_hash: None,
+            has_no_comment: None,
+            has_comment: None,
+            comment_id_filter: None,
+            child_ids: None,
+            start_date_time: None,
+            starts_with: None,
+        },
+    )
+    .await;
+
+    match result {
+        Ok(response) => {
+            println!("Found {} comments", response.comments.len());
+            for comment in response.comments {
+                println!("Comment: {:?}", comment);
+            }
+        }
+        Err(e) => eprintln!("Error fetching comments: {:?}", e),
+    }
+}
 ```
 
+### Using the Authenticated API
+
+```rust
+use fastcomments_sdk::client::apis::configuration::{ApiKey, Configuration};
+use fastcomments_sdk::client::apis::default_api;
+
+#[tokio::main]
+async fn main() {
+    // Create configuration with API key
+    let mut config = Configuration::new();
+    config.api_key = Some(ApiKey {
+        prefix: None,
+        key: "your-api-key".to_string(),
+    });
+
+    // Fetch comments using authenticated API
+    let result = default_api::get_comments(
+        &config,
+        default_api::GetCommentsParams {
+            tenant_id: "your-tenant-id".to_string(),
+            skip: None,
+            limit: None,
+            sort_dir: None,
+            urlid: Some("page-url-id".to_string()),
+            url: None,
+            is_spam: None,
+            user_id: None,
+            all_comments: None,
+            for_moderation: None,
+            parent_id: None,
+            is_flagged: None,
+            is_flagged_tag: None,
+            is_by_verified: None,
+            is_pinned: None,
+            asc: None,
+            include_imported: None,
+            origin: None,
+            tags: None,
+        },
+    )
+    .await;
+
+    match result {
+        Ok(response) => {
+            println!("Total comments: {}", response.count);
+            for comment in response.comments {
+                println!("Comment ID: {}, Text: {}", comment.id, comment.comment);
+            }
+        }
+        Err(e) => eprintln!("Error: {:?}", e),
+    }
+}
+```
+
+### Using SSO for Authentication
+
+```rust
+use fastcomments_sdk::sso::{
+    fastcomments_sso::FastCommentsSSO,
+    secure_sso_user_data::SecureSSOUserData,
+};
+
+fn main() {
+    let api_key = "your-api-key".to_string();
+
+    // Create secure SSO user data (server-side only!)
+    let user_data = SecureSSOUserData::new(
+        "user-123".to_string(),           // User ID
+        "[email protected]".to_string(),   // Email
+        "John Doe".to_string(),            // Username
+        "https://example.com/avatar.jpg".to_string(), // Avatar URL
+    );
+
+    // Generate SSO token
+    let sso = FastCommentsSSO::new_secure(api_key, &user_data).unwrap();
+    let token = sso.create_token().unwrap();
+
+    println!("SSO Token: {}", token);
+    // Pass this token to your frontend for authentication
+}
+```
+
+## Common Issues
+
+### 401 Unauthorized Errors
+
+If you're getting 401 errors when using the authenticated API:
+
+1. **Check your API key**: Ensure you're using the correct API key from your FastComments dashboard
+2. **Verify the tenant ID**: Make sure the tenant ID matches your account
+3. **API key format**: The API key should be passed in the Configuration:
+
+```rust
+let mut config = Configuration::new();
+config.api_key = Some(ApiKey {
+    prefix: None,
+    key: "YOUR_API_KEY".to_string(),
+});
+```
+
+### SSO Token Issues
+
+If SSO tokens aren't working:
+
+1. **Use secure mode for production**: Always use `FastCommentsSSO::new_secure()` with your API key for production
+2. **Server-side only**: Generate SSO tokens on your server, never expose your API key to clients
+3. **Check user data**: Ensure all required fields (id, email, username) are provided
+
+### Async Runtime Errors
+
+The SDK uses tokio for async operations. Make sure to:
+
+1. Add tokio to your dependencies:
+```toml
+[dependencies]
+tokio = { version = "1", features = ["full"] }
+```
+
+2. Use the tokio runtime:
+```rust
+#[tokio::main]
+async fn main() {
+    // Your async code here
+}
+```
+
+## Notes
+
+### Broadcast IDs
+
+You'll see you're supposed to pass a `broadcastId` in some API calls. When you receive events, you'll get this ID back, so you know to ignore the event if you plan to optimistically apply changes on the client
+(which you'll probably want to do since it offers the best experience). Pass a UUID here. The ID should be unique enough to not occur twice in a browser session.
+
+## Support
+
+For issues, questions, or feature requests:
+
+- GitHub Issues: [https://github.com/fastcomments/fastcomments-rust](https://github.com/fastcomments/fastcomments-rust)
+- Documentation: [https://docs.fastcomments.com](https://docs.fastcomments.com)
+- Support: [email protected]
+
+## License
+
+MIT - See [LICENSE](LICENSE) file for details.