acton-cli 0.25.0

CLI tool for scaffolding and managing acton-service backend services
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

pub mod cargo_toml;
pub mod config;
pub mod deployment;
pub mod graphql;
pub mod handlers;
pub mod service;
pub mod worker;

use chrono::Datelike;
use serde::{Deserialize, Serialize};
use serde_json::json;

/// Template data for service generation
#[derive(Debug, Clone, Serialize, Deserialize)]
#[allow(dead_code)]
pub struct ServiceTemplate {
    pub name: String,
    pub pascal_name: String,
    pub snake_name: String,
    pub http: bool,
    pub grpc: bool,
    pub database: Option<String>,
    pub cache: Option<String>,
    pub events: Option<String>,
    pub auth: Option<String>,
    pub observability: bool,
    pub resilience: bool,
    pub rate_limit: bool,
    pub openapi: bool,
    pub audit: bool,
    /// Scaffold a GraphQL transport (versioned schema + GraphiQL).
    pub graphql: bool,
}

impl ServiceTemplate {
    #[allow(dead_code)]
    pub fn to_json(&self) -> serde_json::Value {
        json!({
            "name": self.name,
            "pascal_name": self.pascal_name,
            "snake_name": self.snake_name,
            "http": self.http,
            "grpc": self.grpc,
            "has_database": self.database.is_some(),
            "database": self.database,
            "has_cache": self.cache.is_some(),
            "cache": self.cache,
            "has_events": self.events.is_some(),
            "events": self.events,
            "has_auth": self.auth.is_some(),
            "auth": self.auth,
            "observability": self.observability,
            "resilience": self.resilience,
            "rate_limit": self.rate_limit,
            "openapi": self.openapi,
            "audit": self.audit,
            "graphql": self.graphql,
            "year": chrono::Utc::now().year(),
        })
    }

    pub fn features(&self) -> Vec<String> {
        let mut features = vec![];

        if self.http {
            features.push("http".to_string());
        }

        if self.grpc {
            features.push("grpc".to_string());
        }

        if self.database.is_some() {
            features.push("database".to_string());
        }

        if self.cache.is_some() {
            features.push("cache".to_string());
        }

        if self.events.is_some() {
            features.push("events".to_string());
        }

        if self.observability {
            features.push("observability".to_string());
        }

        if self.resilience {
            features.push("resilience".to_string());
        }

        if self.rate_limit {
            features.push("rate-limit".to_string());
        }

        if self.audit {
            features.push("audit".to_string());
        }

        if self.graphql {
            features.push("graphql".to_string());
        }

        features
    }
}

impl ServiceTemplate {
    /// Calculate acton-service path from CLI manifest directory
    pub fn acton_service_path(&self) -> Option<String> {
        let cli_manifest_dir = env!("CARGO_MANIFEST_DIR");
        if cli_manifest_dir.ends_with("/acton-cli") {
            let workspace_root = cli_manifest_dir.strip_suffix("/acton-cli")?;
            Some(format!("{}/acton-service", workspace_root))
        } else {
            None
        }
    }
}