monosecret 0.2.0

Declarative secrets, every environment, any provider
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

#![allow(clippy::indexing_slicing, unsafe_code)]

//! Monosecret - A declarative secrets manager for development workflows
//!
//! This library provides a type-safe, declarative way to manage secrets and environment
//! variables across different environments and storage backends.
//!
//! # Features
//!
//! - **Declarative Configuration**: Define secrets in `monosecret.toml`
//! - **Multiple Providers**: Keyring, dotenv, environment variables, `OnePassword`, `LastPass`
//! - **Profile Support**: Different configurations for development, staging, production
//! - **Type Safety**: Optional compile-time code generation for strongly-typed access
//! - **Validation**: Ensure all required secrets are present before running applications
//!
//! # Example
//!
//! ```ignore
//! // Generate typed structs from monosecret.toml
//! monosecret_derive::declare_secrets!("monosecret.toml");
//!
//! fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     // Load secrets and configure provider/profile
//!     let mut spec = Secrets::load()?;
//!     spec.set_provider("keyring");  // Can use provider name or URI like "dotenv:/path/to/.env"
//!     spec.set_profile("development");
//!
//!     // Validate and get secrets
//!     let secrets = match spec.validate()? {
//!         Ok(validated) => validated,
//!         Err(errors) => return Err(format!("Missing secrets: {}", errors).into()),
//!     };
//!
//!     // Access secrets (field names are lowercased)
//!     println!("Database: {}", secrets.resolved.secrets.get("DATABASE_URL").unwrap());
//!
//!     // Access profile and provider information
//!     println!("Using profile: {}", secrets.resolved.profile);
//!     println!("Using provider: {}", secrets.resolved.provider);
//!
//!     Ok(())
//! }
//! ```

// Internal modules
#[allow(dead_code)]
mod audit;
pub mod codegen;
mod config;
mod error;
pub(crate) mod generator;
mod report;
mod resolve;
mod secrets;
mod validation;

pub(crate) mod provider;

// CLI module (feature-gated)
#[cfg(feature = "cli")]
pub mod cli;

// Re-export only the types needed by users and generated code
pub use config::NativeAddress;
pub use config::ProviderConfig;
pub use config::ProviderConfigStructured;
pub use config::ProviderDependency;
pub use config::ProviderRef;
pub use config::ProviderRefDetail;
pub use config::Resolved;
pub use config::SecretRequest;
// Re-export config types for CLI usage only - these are marked #[doc(hidden)]
#[doc(hidden)]
pub use config::{
	AuditConfig,
	Config,
	GlobalConfig,
	GlobalDefaults,
	Manifest,
	ManifestProfile,
	ManifestProject,
	ManifestSecret,
	Profile,
	ProfileDefaults,
	Project,
};
// Re-export Secret and generation types for monosecret_derive
#[doc(hidden)]
pub use config::{GenerateConfig, GenerateOptions, Secret};
// Public API exports
pub use error::{MonosecretError, Result};
pub use provider::Address;
pub use provider::Provider;
pub use report::RESOLUTION_REPORT_SCHEMA_VERSION;
pub use report::ResolutionReport;
pub use report::ResolutionStatus;
pub use report::SecretResolution;
pub use resolve::RESOLVE_SCHEMA_VERSION;
pub use resolve::ResolveResponse;
pub use resolve::ResolvedSecret;
pub use resolve::ResolvedSource;
pub use resolve::resolve_json;
pub use secrets::Secrets;
pub use validation::ValidatedSecrets;

#[cfg(test)]
mod tests;