trigger pipeline execution

Author: rawnly

crates/cli/cli.rs

@@ -6,7 +6,7 @@ use commands::aws::PullRequestStatus;
 // #[command(propagate_version = true)]
 pub struct Args {
     #[command(subcommand)]
-    pub command: Commands,
+    pub command: Option<Commands>,
 
     /// do not perform any action
     #[arg(long, global = true)]
@@ -34,10 +34,27 @@ pub enum ReleasePushTarget {
 
 #[derive(Subcommand, strum::Display, Debug, Clone)]
 pub enum ReleaseCommands {
-    Start,
+    Start {
+        #[arg(long)]
+        patch: bool,
+
+        #[arg(long, default_value = "true")]
+        minor: bool,
+
+        #[arg(long)]
+        major: bool,
+    },
     Push {
         #[arg(long, short, default_value = "All")]
         target: ReleasePushTarget,
+
+        /// pipeline to trigger
+        #[arg(long, short = 'n')]
+        pipeline_name: Option<String>,
+
+        /// aws profile
+        #[arg(long, default_value = "default")]
+        profile: String,
     },
     Finish,
 }
@@ -78,23 +95,16 @@ pub enum TicketCommands {
         project: Option<String>,
     },
     /// Run `git flow finish`
-    Finish {
-        id_or_url: Option<String>,
-    },
+    Finish { id_or_url: Option<String> },
 
     /// Print userStory link
-    Link {
-        id_or_url: Option<String>,
-    },
+    Link { id_or_url: Option<String> },
 
     /// Print userStory link
-    GetBranch {
-        id_or_url: String,
-    },
+    GetBranch { id_or_url: String },
 
-    GetId {
-        url: Option<String>,
-    },
+    /// Print userStory ID
+    GetId { url: Option<String> },
 
     /// Print project details
     GetProject {
@@ -108,6 +118,8 @@ pub enum TicketCommands {
         json: bool,
     },
 
+    /// Generate a changelog from a targetprocess release
+    #[clap(alias = "changelog")]
     GenerateChangelog {
         from: usize,
 

crates/cli/main.rs

@@ -11,11 +11,15 @@ use commands::{
     spawn_command,
 };
 use config::{util::get_user_id, Config, ProjectConfig};
+use global_utils::print_dbg;
 use human_panic::setup_panic;
 use mdka::from_html;
 use target_process::{models::EntityStates, SearchOperator};
 
-use crate::{cli::Args, context::GlobalContext, manifests::node::PackageJson};
+use crate::{
+    cli::Args, context::GlobalContext, manifests::node::PackageJson,
+    subcommands::release::ReleaseKind,
+};
 
 mod cli;
 mod context;
@@ -24,9 +28,11 @@ mod manifests;
 mod subcommands;
 mod utils;
 
-fn print_help() {
+fn print_help() -> Result<()> {
     let mut cmd = Args::command();
-    cmd.print_help();
+    cmd.print_help()?;
+
+    Ok(())
 }
 
 fn is_slack_enabled(slack_flag: bool) -> bool {
@@ -61,6 +67,21 @@ async fn main() -> Result<()> {
     #[cfg(debug_assertions)]
     color_eyre::install()?;
 
+    let args = cli::Args::parse();
+
+    if args.version {
+        println!("{}", env!("CARGO_PKG_VERSION"));
+        return Ok(());
+    }
+
+    if args.debug {
+        std::env::set_var("TPAWS_DEBUG", args.debug.to_string());
+    }
+
+    if args.command.is_none() {
+        return print_help();
+    }
+
     if !commands::is_installed!("aws") {
         println!("Useful links:");
         println!(
@@ -73,8 +94,6 @@ async fn main() -> Result<()> {
         return Ok(());
     }
 
-    let args = cli::Args::parse();
-
     if Config::is_first_run()? {
         println!("Please configure the CLI before continue");
         println!();
@@ -92,17 +111,13 @@ async fn main() -> Result<()> {
 
     let create_pr_args = args.clone();
 
-    if args.debug {
-        std::env::set_var("TPAWS_DEBUG", args.debug.to_string());
-    }
-
-    match args.command {
+    match args.command.unwrap() {
         cli::Commands::PullRequest {
             subcommands,
             profile,
             ..
         } => {
-            let branch = git::current_branch().await?;
+            let branch = git::current_branch_v2().await?.0;
             let repository = utils::get_repository().await?;
 
             let region = aws::get_region(profile.clone()).await?;
@@ -438,17 +453,34 @@ async fn main() -> Result<()> {
             }
 
             let pkg = PackageJson::read().await?;
-            let branch = git::current_branch().await?;
+            let branch = git::current_branch_v2().await?;
 
             match subcommands {
-                cli::ReleaseCommands::Start => {
-                    subcommands::release::start(&pkg).await?;
+                cli::ReleaseCommands::Start {
+                    major,
+                    patch,
+                    minor,
+                } => {
+                    let kind: ReleaseKind = match (major, minor, patch) {
+                        (_, _, true) => ReleaseKind::Patch,
+                        (true, _, _) => ReleaseKind::Major,
+                        (_, true, _) => ReleaseKind::Minor,
+                        _ => ReleaseKind::Minor,
+                    };
+
+                    print_dbg!(&kind, major, minor, patch);
+
+                    subcommands::release::start(&pkg, kind).await?;
                 }
-                cli::ReleaseCommands::Push { target } => {
-                    subcommands::release::push(target).await?;
+                cli::ReleaseCommands::Push {
+                    target,
+                    pipeline_name: name,
+                    profile,
+                } => {
+                    subcommands::release::push(target, name, profile).await?;
                 }
                 cli::ReleaseCommands::Finish => {
-                    subcommands::release::finish(&pkg, &branch).await?;
+                    subcommands::release::finish(&pkg, &branch.0).await?;
                 }
             }
         }

crates/cli/manifests/mod.rs

@@ -17,9 +17,15 @@ impl Version {
         self.patch = 0;
     }
 
-    // pub fn bump_patch(&mut self) {
-    //     self.patch += 1
-    // }
+    pub fn bump_patch(&mut self) {
+        self.patch += 1
+    }
+
+    pub fn bump_major(&mut self) {
+        self.patch = 0;
+        self.minor = 0;
+        self.major += 1;
+    }
 }
 
 impl ToString for Version {

crates/cli/subcommands/release/push.rs

@@ -1,9 +1,9 @@
 use color_eyre::{eyre::Context, Result};
-use commands::git;
+use commands::{aws, git};
 
 use crate::cli::ReleasePushTarget;
 
-pub async fn push(target: ReleasePushTarget) -> Result<()> {
+pub async fn push(target: ReleasePushTarget, name: Option<String>, profile: String) -> Result<()> {
     match target {
         ReleasePushTarget::Prod => {
             git::force_push_to_env("origin", "prod")
@@ -26,5 +26,11 @@ pub async fn push(target: ReleasePushTarget) -> Result<()> {
         }
     }
 
+    if let Some(name) = name {
+        println!();
+        aws::start_pipeline_execution(name, profile).await?;
+        println!("Pipeline triggered.");
+    }
+
     Ok(())
 }

crates/cli/subcommands/release/start.rs

@@ -1,20 +1,41 @@
 use color_eyre::{eyre::eyre, Result};
 use commands::{command, git};
+use global_utils::print_dbg;
 use std::str::FromStr;
 
 use crate::manifests::{node::PackageJson, Version};
 
-pub async fn start(pkg: &PackageJson) -> Result<()> {
+#[derive(strum::Display, Debug, Clone, Copy)]
+pub enum ReleaseKind {
+    Patch,
+    Minor,
+    Major,
+}
+
+pub async fn start(pkg: &PackageJson, release_kind: ReleaseKind) -> Result<()> {
     let mut pkg = pkg.clone();
     let prev_version = pkg.version.clone();
     let mut version = Version::from_str(&pkg.version).map_err(|_| eyre!("invalid version"))?;
 
+    print_dbg!(&version);
+
     // bump
-    version.bump_minor();
+    match release_kind {
+        ReleaseKind::Patch => version.bump_patch(),
+        ReleaseKind::Minor => version.bump_minor(),
+        ReleaseKind::Major => version.bump_major(),
+    };
+
+    print_dbg!(&release_kind);
+
     pkg.version = version.to_string();
 
     git::flow::release::start(&version.to_string()).await?;
-    command!("npm", "version", "minor").output().await?;
+
+    let command = &release_kind.to_string();
+    let command = command.to_lowercase();
+
+    command!("npm", "version", &command).output().await?;
 
     println!("version bumped from {prev_version} to: {}", pkg.version);
 

crates/commands/src/aws.rs

@@ -375,3 +375,24 @@ pub async fn merge_pr_by_squash(
     let raw_stderr = String::from_utf8(output.stderr)?;
     Err(CommandError::IOError(raw_stderr))
 }
+
+pub async fn start_pipeline_execution(name: String, profile: String) -> Result<()> {
+    command!(
+        "aws",
+        "codepipeline",
+        "start-pipeline-execution",
+        "--name",
+        &name,
+        "--profile",
+        &profile,
+        "--output",
+        "json",
+        "--color",
+        "off"
+    )
+    .output()
+    .await
+    .map_err(CommandError::from_io)?;
+
+    Ok(())
+}