git_indexer/

client.rs

//! Helix DB client for indexing git repositories.
//!
//! This module provides a client for pushing git repository information
//! to a Helix DB graph database instance.

use crate::error::{ConfigError, HelixError, Result};
use crate::extraction::extract;
use crate::models::{BranchInfo, CommitInfo, FileChange, GitInfo};
use std::path::Path;

/// Client for interacting with a Helix DB instance.
///
/// Use [`GitIndexerClient::builder()`] to create a new client.
///
/// # Example
///
/// ```no_run
/// use git_indexer::GitIndexerClient;
///
/// # async fn example() -> git_indexer::Result<()> {
/// let client = GitIndexerClient::builder()
///     .endpoint("http://localhost:6969")
///     .build()?;
///
/// let git_info = client.index_repository("/path/to/repo").await?;
/// # Ok(())
/// # }
/// ```
#[derive(Debug, Clone)]
pub struct GitIndexerClient {
    endpoint: String,
    // Future: Add helix-db client when implementing actual API calls
    // helix_client: HelixDB,
}

/// Builder for constructing a [`GitIndexerClient`].
#[derive(Debug, Default)]
pub struct GitIndexerClientBuilder {
    endpoint: Option<String>,
}

impl GitIndexerClient {
    /// Create a new builder for configuring a `GitIndexerClient`.
    pub fn builder() -> GitIndexerClientBuilder {
        GitIndexerClientBuilder::default()
    }

    /// Get the configured endpoint URL.
    pub fn endpoint(&self) -> &str {
        &self.endpoint
    }

    /// Index a git repository and push all data to Helix DB.
    ///
    /// This is the main entry point for indexing a repository. It will:
    /// 1. Extract all git information (branches, commits, file changes)
    /// 2. Create nodes for each branch, commit, and file change
    /// 3. Create edges for parent-child commit relationships
    ///
    /// # Arguments
    ///
    /// * `repo_path` - Path to the git repository
    ///
    /// # Returns
    ///
    /// Returns the extracted `GitInfo` after successfully pushing to Helix DB.
    pub async fn index_repository<P: AsRef<Path>>(&self, repo_path: P) -> Result<GitInfo> {
        let git_info = extract(repo_path.as_ref())?;

        // Create branch nodes
        for branch in &git_info.branches {
            self.create_branch_node(branch).await?;
        }

        // Create commit nodes and their relationships
        for commit in &git_info.commits {
            self.create_commit_node(commit).await?;

            // Create file change nodes
            for file_change in &commit.file_changes {
                self.create_file_node(file_change, &commit.id).await?;
            }

            // Create parent edges
            for parent_id in &commit.parent_ids {
                self.create_parent_edge(&commit.id, parent_id).await?;
            }
        }

        Ok(git_info)
    }

    /// Create a commit node in Helix DB.
    ///
    /// # Arguments
    ///
    /// * `commit` - The commit information to store
    pub async fn create_commit_node(&self, commit: &CommitInfo) -> Result<()> {
        // TODO: Implement actual Helix DB API call
        // Example future implementation:
        // ```
        // use helix_db::HelixDB;
        // let payload = serde_json::json!({
        //     "id": commit.id,
        //     "message": commit.message,
        //     "author": commit.author,
        //     "timestamp": commit.timestamp,
        // });
        // self.helix_client.query("CreateCommit", &payload).await?;
        // ```

        let _ = commit; // Suppress unused warning
        Err(HelixError::NotImplemented("create_commit_node".to_string()).into())
    }

    /// Create a branch node in Helix DB.
    ///
    /// # Arguments
    ///
    /// * `branch` - The branch information to store
    pub async fn create_branch_node(&self, branch: &BranchInfo) -> Result<()> {
        // TODO: Implement actual Helix DB API call
        // Example future implementation:
        // ```
        // let payload = serde_json::json!({
        //     "name": branch.name,
        //     "is_head": branch.is_head,
        //     "commit_id": branch.commit_id,
        //     "is_remote": branch.is_remote,
        // });
        // self.helix_client.query("CreateBranch", &payload).await?;
        // ```

        let _ = branch; // Suppress unused warning
        Err(HelixError::NotImplemented("create_branch_node".to_string()).into())
    }

    /// Create a file change node in Helix DB.
    ///
    /// # Arguments
    ///
    /// * `file` - The file change information to store
    /// * `commit_id` - The SHA of the commit this file change belongs to
    pub async fn create_file_node(&self, file: &FileChange, commit_id: &str) -> Result<()> {
        // TODO: Implement actual Helix DB API call
        // Example future implementation:
        // ```
        // let payload = serde_json::json!({
        //     "path": file.path,
        //     "old_path": file.old_path,
        //     "change_type": file.change_type,
        //     "commit_id": commit_id,
        //     "hunks": file.hunks,
        // });
        // self.helix_client.query("CreateFileChange", &payload).await?;
        // ```

        let _ = (file, commit_id); // Suppress unused warning
        Err(HelixError::NotImplemented("create_file_node".to_string()).into())
    }

    /// Create a parent-child edge between commits in Helix DB.
    ///
    /// # Arguments
    ///
    /// * `child_id` - SHA of the child commit
    /// * `parent_id` - SHA of the parent commit
    pub async fn create_parent_edge(&self, child_id: &str, parent_id: &str) -> Result<()> {
        // TODO: Implement actual Helix DB API call
        // Example future implementation:
        // ```
        // let payload = serde_json::json!({
        //     "child_id": child_id,
        //     "parent_id": parent_id,
        // });
        // self.helix_client.query("CreateParentEdge", &payload).await?;
        // ```

        let _ = (child_id, parent_id); // Suppress unused warning
        Err(HelixError::NotImplemented("create_parent_edge".to_string()).into())
    }
}

impl GitIndexerClientBuilder {
    /// Set the Helix DB endpoint URL.
    ///
    /// # Arguments
    ///
    /// * `endpoint` - The URL of the Helix DB instance (e.g., "http://localhost:6969")
    pub fn endpoint<S: Into<String>>(mut self, endpoint: S) -> Self {
        self.endpoint = Some(endpoint.into());
        self
    }

    /// Build the `GitIndexerClient`.
    ///
    /// # Errors
    ///
    /// Returns an error if the endpoint is not set.
    pub fn build(self) -> Result<GitIndexerClient> {
        let endpoint = self
            .endpoint
            .ok_or_else(|| ConfigError::MissingField("endpoint".to_string()))?;

        // Validate endpoint URL format
        if !endpoint.starts_with("http://") && !endpoint.starts_with("https://") {
            return Err(ConfigError::InvalidEndpoint(format!(
                "Endpoint must start with http:// or https://, got: {}",
                endpoint
            ))
            .into());
        }

        Ok(GitIndexerClient { endpoint })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_builder_missing_endpoint() {
        let result = GitIndexerClient::builder().build();
        assert!(result.is_err());
    }

    #[test]
    fn test_builder_invalid_endpoint() {
        let result = GitIndexerClient::builder().endpoint("not-a-url").build();
        assert!(result.is_err());
    }

    #[test]
    fn test_builder_valid_endpoint() {
        let client = GitIndexerClient::builder()
            .endpoint("http://localhost:6969")
            .build()
            .unwrap();
        assert_eq!(client.endpoint(), "http://localhost:6969");
    }

    #[test]
    fn test_builder_https_endpoint() {
        let client = GitIndexerClient::builder()
            .endpoint("https://helix.example.com:6969")
            .build()
            .unwrap();
        assert_eq!(client.endpoint(), "https://helix.example.com:6969");
    }
}