ic-query 0.2.17

Internet Computer query CLI for NNS, SNS, and related public network metadata
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

//! Module: sns::commands::run::common
//!
//! Responsibility: provide shared runtime helpers for SNS command execution.
//! Does not own: command specs, report building, or cache policy.
//! Boundary: adapts CLI-level helpers into SNS command errors and request parts.

use crate::{
    cli::{
        clap::{
            OptionalSubcommand, parse_optional_subcommand_or_usage,
            parse_required_subcommand_or_usage,
        },
        common::{OutputFormat, current_unix_secs},
        help::collect_args_or_print_help_or_version,
    },
    project::icp_root,
    sns::commands::{SnsCommandError, options::SnsLookupOptions},
    version_text,
};
use clap::Command as ClapCommand;
use std::ffi::OsString;
use std::path::PathBuf;

pub(super) struct SnsLookupCommandParts {
    pub(super) format: OutputFormat,
    pub(super) network: String,
    pub(super) source_endpoint: String,
    pub(super) now_unix_secs: u64,
    pub(super) input: String,
}

pub(in crate::sns::commands::run) struct SnsCachedLookupCommandParts {
    pub(in crate::sns::commands::run) format: OutputFormat,
    pub(in crate::sns::commands::run) network: String,
    pub(in crate::sns::commands::run) source_endpoint: String,
    pub(in crate::sns::commands::run) now_unix_secs: u64,
    pub(in crate::sns::commands::run) input: String,
    pub(in crate::sns::commands::run) icp_root: PathBuf,
}

pub(in crate::sns::commands::run) struct SnsCacheCommandParts {
    pub(in crate::sns::commands::run) format: OutputFormat,
    pub(in crate::sns::commands::run) network: String,
    pub(in crate::sns::commands::run) icp_root: PathBuf,
}

pub(super) fn command_unix_secs() -> Result<u64, SnsCommandError> {
    current_unix_secs().map_err(SnsCommandError::Clock)
}

pub(super) fn command_args<I>(args: I, usage: impl FnOnce() -> String) -> Option<Vec<OsString>>
where
    I: IntoIterator<Item = OsString>,
{
    collect_args_or_print_help_or_version(args, usage, version_text())
}

pub(super) fn command_icp_root() -> Result<PathBuf, SnsCommandError> {
    icp_root().map_err(|err| SnsCommandError::Usage(err.to_string()))
}

pub(super) fn parse_required_command<I>(
    command: ClapCommand,
    args: I,
    usage: impl FnOnce() -> String,
) -> Result<(String, Vec<OsString>), SnsCommandError>
where
    I: IntoIterator<Item = OsString>,
{
    parse_required_subcommand_or_usage(command, args, usage).map_err(SnsCommandError::Usage)
}

pub(super) fn parse_optional_command<I>(
    command: ClapCommand,
    args: I,
    usage: impl FnOnce() -> String,
) -> Result<OptionalSubcommand, SnsCommandError>
where
    I: IntoIterator<Item = OsString>,
{
    parse_optional_subcommand_or_usage(command, args, usage).map_err(SnsCommandError::Usage)
}

pub(super) fn lookup_command_parts(
    options: SnsLookupOptions,
) -> Result<SnsLookupCommandParts, SnsCommandError> {
    Ok(SnsLookupCommandParts {
        format: options.format,
        network: options.network,
        source_endpoint: options.source_endpoint,
        now_unix_secs: command_unix_secs()?,
        input: options.input,
    })
}

pub(in crate::sns::commands::run) fn cached_lookup_command_parts(
    options: SnsLookupOptions,
) -> Result<SnsCachedLookupCommandParts, SnsCommandError> {
    let parts = lookup_command_parts(options)?;
    Ok(SnsCachedLookupCommandParts {
        format: parts.format,
        network: parts.network,
        source_endpoint: parts.source_endpoint,
        now_unix_secs: parts.now_unix_secs,
        input: parts.input,
        icp_root: command_icp_root()?,
    })
}

pub(in crate::sns::commands::run) fn cache_command_parts(
    format: OutputFormat,
    network: String,
) -> Result<SnsCacheCommandParts, SnsCommandError> {
    Ok(SnsCacheCommandParts {
        format,
        network,
        icp_root: command_icp_root()?,
    })
}