bijux-cli 0.4.1

Command-line runtime for automation, plugin-driven tools, and interactive workflows with structured output.
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
120
121
122
123
124
125
126
127
128
129
130

#![forbid(unsafe_code)]
//! Config feature operations exposed to command adapters.

use std::path::Path;

use anyhow::{anyhow, Result};
use serde_json::Value;

use super::layered::{self, LayeredConfigOptions};
use crate::features::config::service::{
    ConfigService, DefaultConfigService, StaticConfigPathProvider,
};
use crate::features::config::storage::FileConfigRepository;

fn config_service(
    config_file: &Path,
) -> DefaultConfigService<StaticConfigPathProvider, FileConfigRepository> {
    DefaultConfigService::new(
        StaticConfigPathProvider::new(config_file.to_path_buf()),
        FileConfigRepository,
    )
}

pub(crate) fn list_entries(config_file: &Path) -> Result<Value> {
    config_service(config_file).list_entries().map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn get_value(config_file: &Path, key: &str) -> Result<Value> {
    config_service(config_file).get_value(key).map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn set_pair(config_file: &Path, pair: &str) -> Result<Value> {
    config_service(config_file).set_pair(pair).map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn unset_key(config_file: &Path, key: &str) -> Result<Value> {
    config_service(config_file).unset_key(key).map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn clear_all(config_file: &Path) -> Result<Value> {
    config_service(config_file).clear_all().map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn reload(config_file: &Path) -> Result<Value> {
    config_service(config_file).reload().map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn export_to(config_file: &Path, export_path: &Path) -> Result<Value> {
    config_service(config_file).export_to(export_path).map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn load_from(config_file: &Path, source_path: &Path) -> Result<Value> {
    config_service(config_file)
        .load_from(source_path)
        .map_err(|err| anyhow!("Failed to load config: {}", err))
}

pub(crate) fn schema(scope: Option<&str>) -> Result<Value> {
    layered::schema_report(scope).map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn docs(scope: Option<&str>) -> Result<Value> {
    layered::schema_docs_report(scope).map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn validate(
    config_file: &Path,
    cwd: &Path,
    profile: Option<&str>,
    overrides: &[String],
) -> Result<Value> {
    layered::validate_report(config_file, cwd, profile, overrides)
        .map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn explain(
    config_file: &Path,
    cwd: &Path,
    key: &str,
    profile: Option<&str>,
    overrides: &[String],
    include_secrets: bool,
) -> Result<Value> {
    layered::explain_report(config_file, cwd, key, profile, overrides, include_secrets)
        .map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn diff(
    config_file: &Path,
    cwd: &Path,
    key: Option<&str>,
    from_profile: Option<&str>,
    to_profile: Option<&str>,
    overrides: &[String],
    include_secrets: bool,
) -> Result<Value> {
    layered::diff_report(
        config_file,
        cwd,
        key,
        from_profile,
        to_profile,
        overrides,
        include_secrets,
    )
    .map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn repair(config_file: &Path) -> Result<Value> {
    layered::repair_report(config_file).map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn export_with_options(
    config_file: &Path,
    cwd: &Path,
    export_path: &Path,
    options: &LayeredConfigOptions,
) -> Result<Value> {
    layered::export_report(config_file, cwd, export_path, options)
        .map_err(|err| anyhow!(err.to_string()))
}

pub(crate) fn load_with_options(
    config_file: &Path,
    source_path: &Path,
    options: &LayeredConfigOptions,
) -> Result<Value> {
    layered::load_report(config_file, source_path, options)
        .map_err(|err| anyhow!("Failed to load config: {}", err))
}