provisional migration to cling

This allows us to experiment with cling's design and limitations in practice. There will be further improvements but this is a fully functional migration.

cronback-cli/Cargo.toml

@@ -26,6 +26,7 @@ admin = ["cronback-client/admin", "cronback-api-model/admin"]
 [dependencies]
 cronback-client = { workspace = true }
 cronback-api-model = { workspace = true, features = ["client", "clap"] }
+cling = { git = "https://github.com/AhmedSoliman/cling.git", version = "0.0.0-alpha.2" }
 
 anyhow = { version = "1.0.71" }
 async-trait = { workspace = true }

cronback-cli/src/admin/api_keys/create.rs

@@ -1,45 +1,32 @@
 use anyhow::Result;
-use async_trait::async_trait;
-use clap::Parser;
+use cling::prelude::*;
 use cronback_api_model::admin::APIKeyMetaData;
 
 use crate::args::CommonOptions;
-use crate::{emitln, Command};
 
-#[derive(Clone, Debug, Parser)]
+#[derive(CliRunnable, CliParam, Clone, Debug, Parser)]
+#[cling(run = "create")]
 pub struct Create {
  /// The name of the key to be created
  name: String,
 }
 
-#[async_trait]
-impl Command for Create {
- async fn run<
- A: tokio::io::AsyncWrite + Send + Sync + Unpin,
- B: tokio::io::AsyncWrite + Send + Sync + Unpin,
- >(
- &self,
- out: &mut tokio::io::BufWriter<A>,
- _err: &mut tokio::io::BufWriter<B>,
- common_options: &CommonOptions,
- ) -> Result<()> {
- let client = common_options.new_client()?;
+async fn create(common_options: &CommonOptions, opts: &Create) -> Result<()> {
+ let client = common_options.new_client()?;
 
-  let response = cronback_client::api_keys::gen(
-  &client,
-  &self.name,
-  APIKeyMetaData::default(),
-  )
-  .await?;
+ let response = cronback_client::api_keys::gen(
+ &client,
+ &opts.name,
+ APIKeyMetaData::default(),
+ )
+ .await?;
 
-  let response = response.into_inner()?;
+ let response = response.into_inner()?;
 
- emitln!(
- out,
- "API key with the name '{}' was created successfully.",
- self.name
- );
- emitln!(out, "Secret key: '{}'", response.key);
- Ok(())
- }
+ println!(
+ "API key with the name '{}' was created successfully.",
+ opts.name
+ );
+ println!("Secret key: '{}'", response.key);
+ Ok(())
 }

cronback-cli/src/admin/api_keys/list.rs

@@ -1,45 +1,29 @@
 use anyhow::Result;
-use async_trait::async_trait;
-use clap::Parser;
+use cling::prelude::*;
 use prettytable::{row, Table};
 
 use crate::args::CommonOptions;
-use crate::{emitln, Command};
 
-#[derive(Clone, Debug, Parser)]
-pub struct List {}
+#[derive(CliRunnable, Clone, Debug, Parser)]
+#[cling(run = "list")]
+pub struct List;
 
-#[async_trait]
-impl Command for List {
- async fn run<
- A: tokio::io::AsyncWrite + Send + Sync + Unpin,
- B: tokio::io::AsyncWrite + Send + Sync + Unpin,
- >(
- &self,
- out: &mut tokio::io::BufWriter<A>,
- _err: &mut tokio::io::BufWriter<B>,
- common_options: &CommonOptions,
- ) -> Result<()> {
- let client = common_options.new_client()?;
+async fn list(common_options: &CommonOptions) -> Result<()> {
+ let client = common_options.new_client()?;
 
-  let response = cronback_client::api_keys::list(&client).await?;
+ let response = cronback_client::api_keys::list(&client).await?;
 
- let response = response.into_inner()?;
- // Print Table
- if !response.data.is_empty() {
- let mut table = Table::new();
- table.set_titles(row!["Id", "Name", "Created At"]);
- for key in response.data {
- table.add_row(row![
- key.id,
- key.name,
- key.created_at.to_rfc2822(),
- ]);
- }
-
- emitln!(out, "{}", table);
+ let response = response.into_inner()?;
+ // Print Table
+ if !response.data.is_empty() {
+ let mut table = Table::new();
+ table.set_titles(row!["Id", "Name", "Created At"]);
+ for key in response.data {
+ table.add_row(row![key.id, key.name, key.created_at.to_rfc2822(),]);
  }
 
- Ok(())
+ println!("{}", table);
  }
+
+ Ok(())
 }

cronback-cli/src/admin/api_keys/mod.rs

@@ -1,15 +1,10 @@
-use anyhow::Result;
-use async_trait::async_trait;
-use clap::clap_derive::Parser;
-
-use crate::args::CommonOptions;
-use crate::Command;
+use cling::prelude::*;
 
 mod create;
 mod list;
 mod revoke;
 
-#[derive(Parser, Debug, Clone)]
+#[derive(CliRunnable, Subcommand, Debug, Clone)]
 pub enum ApiKeysCommand {
  /// List API keys
  #[command(visible_alias = "ls")]
@@ -19,26 +14,3 @@ pub enum ApiKeysCommand {
  /// Revokes an API key
  Revoke(revoke::Revoke),
 }
-
-#[async_trait]
-impl Command for ApiKeysCommand {
- async fn run<
- A: tokio::io::AsyncWrite + Send + Sync + Unpin,
- B: tokio::io::AsyncWrite + Send + Sync + Unpin,
- >(
- &self,
- out: &mut tokio::io::BufWriter<A>,
- err: &mut tokio::io::BufWriter<B>,
- common_options: &CommonOptions,
- ) -> Result<()> {
- match self {
- | ApiKeysCommand::List(c) => c.run(out, err, common_options).await,
- | ApiKeysCommand::Create(c) => {
- c.run(out, err, common_options).await
- }
- | ApiKeysCommand::Revoke(c) => {
- c.run(out, err, common_options).await
- }
- }
- }
-}

cronback-cli/src/admin/api_keys/revoke.rs

@@ -1,12 +1,11 @@
 use anyhow::Result;
-use async_trait::async_trait;
-use clap::Parser;
+use cling::prelude::*;
 
 use crate::args::CommonOptions;
 use crate::confirm::confirm_or_abort;
-use crate::{emitln, Command};
 
-#[derive(Clone, Debug, Parser)]
+#[derive(CliRunnable, CliParam, Clone, Debug, Parser)]
+#[cling(run = "revoke")]
 pub struct Revoke {
  /// The Id of the key to be revoked
  id: String,
@@ -16,33 +15,21 @@ pub struct Revoke {
  yes: bool,
 }
 
-#[async_trait]
-impl Command for Revoke {
- async fn run<
- A: tokio::io::AsyncWrite + Send + Sync + Unpin,
- B: tokio::io::AsyncWrite + Send + Sync + Unpin,
- >(
- &self,
- out: &mut tokio::io::BufWriter<A>,
- _err: &mut tokio::io::BufWriter<B>,
- common_options: &CommonOptions,
- ) -> Result<()> {
- confirm_or_abort!(
- self,
- "Are you sure you want to revoke the key '{}'? All API calls with \
- this key will start failing.",
- self.id
- );
- let client = common_options.new_client()?;
-
- let response =
- cronback_client::api_keys::revoke(&client, &self.id).await?;
-
- // Ensure that the request actually succeeded
- response.into_inner()?;
-
- emitln!(out, "Key with id '{}' was revoked!", self.id);
-
- Ok(())
- }
+async fn revoke(common_options: &CommonOptions, opts: &Revoke) -> Result<()> {
+ confirm_or_abort!(
+ opts,
+ "Are you sure you want to revoke the key '{}'? All API calls with \
+ this key will start failing.",
+ opts.id
+ );
+ let client = common_options.new_client()?;
+
+ let response = cronback_client::api_keys::revoke(&client, &opts.id).await?;
+
+ // Ensure that the request actually succeeded
+ response.into_inner()?;
+
+ println!("Key with id '{}' was revoked!", opts.id);
+
+ Ok(())
 }

cronback-cli/src/admin/mod.rs

@@ -1,46 +1,14 @@
-use anyhow::Result;
-use async_trait::async_trait;
-use clap::clap_derive::Parser;
-
-use crate::args::CommonOptions;
-use crate::Command;
+use cling::prelude::*;
 
 mod api_keys;
 mod projects;
 
-#[derive(Parser, Debug, Clone)]
+#[derive(CliRunnable, Subcommand, Debug, Clone)]
 pub enum AdminCommand {
  /// Commands for api key management. This subcommand requires admin
  /// privilliages.
- ApiKeys {
- #[command(subcommand)]
- command: api_keys::ApiKeysCommand,
- },
-
- Projects {
- #[command(subcommand)]
- command: projects::ProjectsCommand,
- },
-}
-
-#[async_trait]
-impl Command for AdminCommand {
- async fn run<
- A: tokio::io::AsyncWrite + Send + Sync + Unpin,
- B: tokio::io::AsyncWrite + Send + Sync + Unpin,
- >(
- &self,
- out: &mut tokio::io::BufWriter<A>,
- err: &mut tokio::io::BufWriter<B>,
- common_options: &CommonOptions,
- ) -> Result<()> {
- match self {
- | AdminCommand::ApiKeys { command } => {
- command.run(out, err, common_options).await
- }
- | AdminCommand::Projects { command } => {
- command.run(out, err, common_options).await
- }
- }
- }
+ #[command(subcommand)]
+ ApiKeys(api_keys::ApiKeysCommand),
+ #[command(subcommand)]
+ Projects(projects::ProjectsCommand),
 }