wepub 1.0.3

CLI to publish browser extensions to Chrome Web Store, Firefox Add-ons, and Edge Add-ons
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

use anyhow::{Result, bail};
use wepub_core::chrome::{self, PublishType};

use crate::cli::{ChromeArgs, ChromePublishTypeArg};

use super::input::read_binary_input;

pub(crate) async fn run(args: ChromeArgs) -> Result<()> {
    let auth = build_auth(
        args.client_id,
        args.client_secret,
        args.refresh_token,
        args.access_token,
    )?;

    let package = read_binary_input(&args.package, "package").await?;

    let access_token = match auth {
        Auth::AccessToken(access_token) => access_token,
        Auth::RefreshToken {
            client_id,
            client_secret,
            refresh_token,
        } => {
            chrome::fetch_access_token()
                .client_id(client_id)
                .client_secret(client_secret)
                .refresh_token(refresh_token)
                .call()
                .await?
        }
    };

    chrome::publish()
        .publisher_id(args.publisher_id)
        .item_id(args.item_id)
        .access_token(access_token)
        .package(package)
        .maybe_publish_type(args.publish_type.map(Into::into))
        .maybe_deploy_percentage(args.deploy_percentage)
        .maybe_skip_review(args.skip_review)
        .call()
        .await?;

    Ok(())
}

impl From<ChromePublishTypeArg> for PublishType {
    fn from(value: ChromePublishTypeArg) -> Self {
        match value {
            ChromePublishTypeArg::Default => PublishType::DefaultPublish,
            ChromePublishTypeArg::Staged => PublishType::StagedPublish,
        }
    }
}

enum Auth {
    RefreshToken {
        client_id: String,
        client_secret: String,
        refresh_token: String,
    },
    AccessToken(String),
}

fn build_auth(
    client_id: Option<String>,
    client_secret: Option<String>,
    refresh_token: Option<String>,
    access_token: Option<String>,
) -> Result<Auth> {
    let any_refresh_token_arg =
        client_id.is_some() || client_secret.is_some() || refresh_token.is_some();

    match (any_refresh_token_arg, access_token) {
        (true, Some(_)) => bail!(
            "--client-id / --client-secret / --refresh-token cannot be combined with --access-token"
        ),
        (false, None) => bail!(
            "missing credentials: pass either the trio \
             --client-id / --client-secret / --refresh-token or --access-token"
        ),
        (true, None) => {
            let (Some(client_id), Some(client_secret), Some(refresh_token)) =
                (client_id, client_secret, refresh_token)
            else {
                bail!(
                    "--client-id / --client-secret / --refresh-token must all be provided together"
                );
            };
            Ok(Auth::RefreshToken {
                client_id,
                client_secret,
                refresh_token,
            })
        }
        (false, Some(access_token)) => Ok(Auth::AccessToken(access_token)),
    }
}