use async_trait::async_trait;
use chrono::{DateTime, Utc};
use gitflow_core::{
CoreError, Result,
review::{ReviewData, ReviewProvider, ReviewState},
types::UserSummary,
};
use serde::Deserialize;
use tracing::debug;
use crate::error::parse_glab_error;
#[derive(Debug, Clone)]
pub struct GitLabReviewProvider {
repo: String,
}
impl GitLabReviewProvider {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
Self { repo: repo.into() }
}
}
#[derive(Debug, Clone, Deserialize)]
struct NoteApiResponse {
id: u64,
#[serde(default)]
body: String,
#[serde(default)]
author: Option<ApiUser>,
#[serde(default)]
created_at: Option<DateTime<Utc>>,
}
#[derive(Debug, Clone, Deserialize)]
struct ApiUser {
username: String,
#[serde(default)]
id: u64,
}
impl From<&ApiUser> for UserSummary {
fn from(u: &ApiUser) -> Self {
Self {
login: u.username.clone(),
id: u.id.to_string(),
}
}
}
#[derive(Debug, Clone, Deserialize)]
struct MrViewResponse {
#[serde(default)]
author: Option<ApiUser>,
}
#[async_trait]
impl ReviewProvider for GitLabReviewProvider {
async fn comment(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
debug!(repo = %self.repo, number = pr_number, "spawning `glab mr note`");
let output = tokio::process::Command::new("glab")
.args(["mr", "note"])
.arg(pr_number.to_string())
.arg("--repo")
.arg(&self.repo)
.arg("--body")
.arg(body)
.arg("--output")
.arg("json")
.output()
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let note: NoteApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
let author = note.author.as_ref().map_or_else(
|| UserSummary {
login: "unknown".into(),
id: "0".to_string(),
},
UserSummary::from,
);
Ok(ReviewData {
id: note.id,
state: ReviewState::Commented,
body: Some(note.body),
author,
submitted_at: note.created_at.unwrap_or_else(Utc::now),
})
}
async fn approve(&self, pr_number: u64, body: Option<&str>) -> Result<ReviewData> {
debug!(repo = %self.repo, number = pr_number, "spawning `glab mr approve`");
let mut cmd = tokio::process::Command::new("glab");
cmd.args(["mr", "approve"])
.arg(pr_number.to_string())
.arg("--repo")
.arg(&self.repo);
if let Some(b) = body {
cmd.arg("--comment").arg(b);
}
let output = cmd
.output()
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
let author = self.get_current_user().await.unwrap_or(UserSummary {
login: "unknown".into(),
id: "0".to_string(),
});
Ok(ReviewData {
id: 0,
state: ReviewState::Approved,
body: if message.is_empty() {
body.map(String::from)
} else {
Some(message)
},
author,
submitted_at: Utc::now(),
})
}
async fn request_changes(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
debug!(
repo = %self.repo,
number = pr_number,
"spawning `glab mr note` (request changes)"
);
let changes_body = format!("Changes requested:\n\n{body}");
let output = tokio::process::Command::new("glab")
.args(["mr", "note"])
.arg(pr_number.to_string())
.arg("--repo")
.arg(&self.repo)
.arg("--body")
.arg(&changes_body)
.arg("--output")
.arg("json")
.output()
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let note: NoteApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
let author = note.author.as_ref().map_or_else(
|| UserSummary {
login: "unknown".into(),
id: "0".to_string(),
},
UserSummary::from,
);
Ok(ReviewData {
id: note.id,
state: ReviewState::ChangesRequested,
body: Some(note.body),
author,
submitted_at: note.created_at.unwrap_or_else(Utc::now),
})
}
async fn submit_review(
&self,
pr_number: u64,
event: ReviewState,
body: Option<&str>,
) -> Result<ReviewData> {
debug!(repo = %self.repo, number = pr_number, ?event, "spawning `glab mr review`");
match event {
ReviewState::Approved => self.approve(pr_number, body).await,
ReviewState::ChangesRequested => {
self.request_changes(pr_number, body.unwrap_or("Changes requested."))
.await
}
ReviewState::Commented => {
self.comment(pr_number, body.unwrap_or("Review comment."))
.await
}
}
}
}
impl GitLabReviewProvider {
async fn get_current_user(&self) -> Result<UserSummary> {
let output = tokio::process::Command::new("glab")
.args(["mr", "list"])
.arg("--repo")
.arg(&self.repo)
.arg("--output")
.arg("json")
.arg("--per-page")
.arg("1")
.output()
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Ok(UserSummary {
login: "unknown".into(),
id: "0".to_string(),
});
}
let mrs: Vec<MrViewResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
if let Some(mr) = mrs.into_iter().next()
&& let Some(author) = mr.author
{
return Ok(UserSummary::from(&author));
}
Ok(UserSummary {
login: "unknown".into(),
id: "0".to_string(),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_should_construct_gitlab_review_provider() {
let provider = GitLabReviewProvider::new("gitlab-org/gitlab");
assert_eq!(provider.repo, "gitlab-org/gitlab");
}
#[test]
fn test_should_construct_gitlab_review_provider_from_string() {
let repo = String::from("gitlab-org/gitlab");
let provider = GitLabReviewProvider::new(repo);
assert_eq!(provider.repo, "gitlab-org/gitlab");
}
#[test]
fn test_should_deserialize_note_api_response() {
let json = br#"{
"id": 2001,
"body": "Looks great, LGTM!",
"author": {"username": "reviewer", "id": 42},
"created_at": "2026-05-20T14:30:00Z"
}"#;
let note: NoteApiResponse = serde_json::from_slice(json).expect("valid NoteApiResponse");
assert_eq!(note.id, 2001);
assert_eq!(note.body, "Looks great, LGTM!");
assert_eq!(note.author.as_ref().map(|a| &*a.username), Some("reviewer"));
}
#[test]
fn test_should_deserialize_note_without_author() {
let json = br#"{
"id": 2002,
"body": "Anonymous comment",
"author": null,
"created_at": "2026-05-21T09:00:00Z"
}"#;
let note: NoteApiResponse = serde_json::from_slice(json).expect("valid NoteApiResponse");
assert!(note.author.is_none());
}
#[test]
fn test_should_convert_note_to_review_data() {
let note = NoteApiResponse {
id: 100,
body: "LGTM".into(),
author: Some(ApiUser {
username: "reviewer".into(),
id: 5,
}),
created_at: Some("2026-01-01T00:00:00Z".parse().expect("valid date")),
};
let author = note
.author
.as_ref()
.map(UserSummary::from)
.expect("has author");
let review = ReviewData {
id: note.id,
state: ReviewState::Commented,
body: Some(note.body),
author,
submitted_at: note.created_at.expect("has date"),
};
assert_eq!(review.id, 100);
assert_eq!(review.state, ReviewState::Commented);
assert_eq!(review.author.login, "reviewer");
}
#[test]
fn test_should_debug_format_provider() {
let provider = GitLabReviewProvider::new("gitlab-org/gitlab");
let debug = format!("{provider:?}");
assert!(debug.contains("GitLabReviewProvider"));
assert!(debug.contains("gitlab-org/gitlab"));
}
#[test]
fn test_should_clone_gitlab_review_provider() {
let original = GitLabReviewProvider::new("owner/repo");
let cloned = original.clone();
assert_eq!(original.repo, cloned.repo);
}
}