inklog 0.1.2

Enterprise-grade Rust logging infrastructure
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

// Copyright (c) 2026 Kirky.X
//
// Licensed under the MIT License
// See LICENSE file in the project root for full license information.

//! `InklogModule` — trait-kit module definition for the inklog logging system.
//!
//! [`InklogModule`] implements [`trait_kit::core::module::Module`] and exposes
//! a [`trait_kit::kit::Kit`] as its capability. The [`InklogModuleBuilder`]
//! constructs a `Kit` pre-populated with the [`InklogConfig`] typed config,
//! enabling downstream trait-kit modules to require the config and register
//! additional capabilities (cache, database) on the same shared `Kit`.
//!
//! # Example
//!
//! ```ignore
//! use inklog::integrations::kit::{InklogModule, InklogModuleBuilder};
//! use trait_kit::prelude::*;
//!
//! let kit = InklogModuleBuilder::new()
//!     .config(inklog::InklogConfig::default())
//!     .build()?;
//! ```

use trait_kit::core::builder::{ModuleBuilder, WithConfig};
use trait_kit::core::marker::NoRequirements;
use trait_kit::core::module::Module;
use trait_kit::kit::Kit;

use crate::integrations::kit::keys::InklogConfigKey;
use crate::{InklogConfig, InklogError};

/// trait-kit module definition for the inklog logging system.
///
/// The module's capability is a [`Kit`] pre-populated with [`InklogConfig`].
/// Use [`InklogModuleBuilder`] to construct it.
pub struct InklogModule;

impl Module for InklogModule {
    const NAME: &'static str = "inklog";

    type Config = InklogConfig;
    type Requirements = NoRequirements;
    type Capability = Kit;
    type Error = InklogError;
    type Builder = InklogModuleBuilder;
}

/// Builder for [`InklogModule`].
///
/// Produces a [`Kit`] with the provided [`InklogConfig`] registered under
/// [`InklogConfigKey`]. Additional capabilities (cache, database) can be
/// registered on the returned `Kit` after build.
pub struct InklogModuleBuilder {
    config: Option<InklogConfig>,
}

impl InklogModuleBuilder {
    /// Create a new builder with no config (use `WithConfig::config()` to set it).
    pub fn new() -> Self {
        Self { config: None }
    }
}

impl Default for InklogModuleBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl WithConfig<InklogModule> for InklogModuleBuilder {
    fn config(mut self, config: InklogConfig) -> Self {
        self.config = Some(config);
        self
    }
}

impl ModuleBuilder<InklogModule> for InklogModuleBuilder {
    fn build(self) -> Result<Kit, InklogError> {
        let kit = Kit::new();
        let config = self.config.unwrap_or_default();
        kit.set_config::<InklogConfigKey>(config);
        Ok(kit)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Arc;
    use trait_kit::core::marker::NoConfig;

    #[test]
    fn module_name() {
        assert_eq!(InklogModule::NAME, "inklog");
    }

    #[test]
    fn builder_default_uses_default_config() {
        let kit = InklogModuleBuilder::default().build().unwrap();
        let handle = kit.config::<InklogConfigKey>().unwrap();
        assert_eq!(handle.load().global.level, "info");
    }

    #[test]
    fn builder_with_config_stores_provided_config() {
        let mut config = InklogConfig::default();
        config.global.level = "debug".to_string();

        let kit = InklogModuleBuilder::new().config(config).build().unwrap();

        let handle = kit.config::<InklogConfigKey>().unwrap();
        assert_eq!(handle.load().global.level, "debug");
    }

    #[test]
    fn builder_new_starts_empty() {
        let builder = InklogModuleBuilder::new();
        assert!(builder.config.is_none());
    }

    #[test]
    fn built_kit_is_empty_of_capabilities() {
        use crate::integrations::kit::keys::CacheCapabilityKey;

        let kit = InklogModuleBuilder::default().build().unwrap();
        assert!(!kit.contains::<CacheCapabilityKey>());
    }

    #[test]
    fn built_kit_can_register_additional_capabilities() {
        use crate::integrations::infra::{Cache, MockCache};
        use crate::integrations::kit::keys::CacheCapabilityKey;

        let kit = InklogModuleBuilder::default().build().unwrap();
        let cache: Arc<dyn Cache> = Arc::new(MockCache::new());
        kit.provide::<CacheCapabilityKey>(cache).unwrap();

        assert!(kit.contains::<CacheCapabilityKey>());
    }

    #[test]
    fn no_config_marker_is_default() {
        let _ = NoConfig;
    }

    #[test]
    fn no_requirements_marker_is_default() {
        let _ = NoRequirements;
    }
}