apiforge 0.4.0

Production-grade API release automation CLI. From merged code to healthy pods in production — one command.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::error::{ApiForgeError, Result};
use crate::steps::{Step, StepContext, StepOutput};
use crate::utils::TemplateEngine;
use async_trait::async_trait;
use semver::Version;
use std::collections::HashMap;

pub struct WebhookNotifyStep {
    version: Version,
    success: bool,
    error_message: Option<String>,
}

impl WebhookNotifyStep {
    pub fn new(version: Version, success: bool) -> Self {
        Self {
            version,
            success,
            error_message: None,
        }
    }

    pub fn with_error(mut self, error: String) -> Self {
        self.error_message = Some(error);
        self
    }

    async fn send_webhook(&self, ctx: &StepContext) -> Result<()> {
        let webhook_config = ctx
            .config
            .notifications
            .as_ref()
            .and_then(|n| n.webhook.as_ref())
            .ok_or_else(|| ApiForgeError::Config("Webhook configuration missing".to_string()))?;

        // Build template context
        let mut template_ctx = HashMap::new();
        template_ctx.insert("version".to_string(), self.version.to_string());
        template_ctx.insert("project".to_string(), ctx.config.project.name.clone());
        template_ctx.insert(
            "status".to_string(),
            if self.success { "success" } else { "failed" }.to_string(),
        );
        if let Some(ref error) = self.error_message {
            template_ctx.insert("error".to_string(), error.clone());
        }

        let mut engine = TemplateEngine::new();
        let body = engine.render(&webhook_config.body, &template_ctx)?;

        let client = reqwest::Client::new();
        let mut request = match webhook_config.method.to_uppercase().as_str() {
            "POST" => client.post(&webhook_config.url),
            "PUT" => client.put(&webhook_config.url),
            "PATCH" => client.patch(&webhook_config.url),
            _ => client.post(&webhook_config.url),
        };

        // Add custom headers
        if let Some(ref headers) = webhook_config.headers {
            for (key, value) in headers {
                let resolved_value = engine.render(value, &template_ctx)?;
                request = request.header(key, resolved_value);
            }
        }

        // Try to parse body as JSON, otherwise send as plain text
        let response = if let Ok(json_body) = serde_json::from_str::<serde_json::Value>(&body) {
            request.json(&json_body).send().await
        } else {
            request
                .header("Content-Type", "text/plain")
                .body(body)
                .send()
                .await
        }
        .map_err(|e| ApiForgeError::StepFailed(format!("Webhook request failed: {}", e)))?;

        if !response.status().is_success() {
            let status = response.status();
            let body = response.text().await.unwrap_or_default();
            return Err(ApiForgeError::StepFailed(format!(
                "Webhook returned error {}: {}",
                status, body
            )));
        }

        Ok(())
    }
}

#[async_trait]
impl Step for WebhookNotifyStep {
    fn name(&self) -> &str {
        "webhook-notify"
    }

    fn description(&self) -> &str {
        "Send webhook notification"
    }

    async fn validate(&self, ctx: &StepContext) -> Result<()> {
        let webhook = ctx
            .config
            .notifications
            .as_ref()
            .and_then(|n| n.webhook.as_ref());

        if webhook.is_none() {
            return Err(ApiForgeError::Config(
                "Webhook configuration missing".to_string(),
            ));
        }

        Ok(())
    }

    async fn execute(&self, ctx: &StepContext) -> Result<StepOutput> {
        self.send_webhook(ctx).await?;
        Ok(StepOutput::ok("Webhook notification sent"))
    }

    async fn dry_run(&self, ctx: &StepContext) -> Result<StepOutput> {
        let webhook_config = ctx
            .config
            .notifications
            .as_ref()
            .and_then(|n| n.webhook.as_ref());

        match webhook_config {
            Some(config) => Ok(StepOutput::ok(format!(
                "Would send {} request to {}",
                config.method, config.url
            ))),
            None => Ok(StepOutput::skipped("No webhook configuration")),
        }
    }
}