use std::any::TypeId;
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use nebulaid::core::algorithm::algorithm_factories;
use nebulaid::core::types::AlgorithmType;
use nebulaid::sdk::NebulaIdKitBuilder;
use trait_kit::core::{AsyncAutoBuilder, ModuleMeta};
use trait_kit::kit::AsyncKit;
use super::settings_module::SettingsModule;
use super::ModuleBuildError;
use crate::domain::services::id_service::IdService;
pub struct IdModule;
impl ModuleMeta for IdModule {
const NAME: &'static str = "id-generation";
fn dependencies() -> &'static [(&'static str, TypeId)] {
static DEPS: [(&str, TypeId); 1] = [(SettingsModule::NAME, TypeId::of::<SettingsModule>())];
&DEPS
}
}
fn resolve_algorithm(name: &str) -> Result<AlgorithmType, String> {
let algorithm = name.parse::<AlgorithmType>().map_err(|e| {
crate::i18n::tr_log_args(
"error-id-algorithm-unknown",
&[("algorithm", name.to_string()), ("error", e.to_string())],
)
})?;
if !algorithm_factories().contains_key(&algorithm) {
return Err(crate::i18n::tr_log_args(
"error-id-algorithm-uncompiled",
&[("algorithm", name.to_string())],
));
}
Ok(algorithm)
}
impl AsyncAutoBuilder for IdModule {
type Capability = Arc<IdService>;
type Error = ModuleBuildError;
fn build<'a>(
kit: &'a AsyncKit,
) -> Pin<Box<dyn Future<Output = Result<Self::Capability, Self::Error>> + Send + 'a>> {
Box::pin(async move {
let settings = kit.require::<SettingsModule>()?;
resolve_algorithm(&settings.id.algorithm).map_err(ModuleBuildError::IdInit)?;
let mut config = nebulaid::core::Config::default();
config.algorithm.default = settings.id.algorithm.clone();
config.etcd.endpoints = Vec::new();
let nebula_kit = NebulaIdKitBuilder::new(config)
.build()
.await
.map_err(|e| ModuleBuildError::IdInit(e.to_string()))?;
let generator = nebula_kit
.id_generator()
.map_err(|e| ModuleBuildError::IdInit(e.to_string()))?;
let nebula_kit = Arc::new(nebula_kit);
crate::domain::id::generator::init(
generator.clone(),
settings.id.workspace.clone(),
settings.id.group.clone(),
)
.await
.map_err(|e| ModuleBuildError::IdInit(e.to_string()))?;
let service = Arc::new(IdService::new(
nebula_kit,
generator,
settings.id.workspace.clone(),
settings.id.group.clone(),
));
log::info!(
"{}",
crate::i18n::tr_log_args(
"id-service-initialized",
&[
("algorithm", settings.id.algorithm.to_string(),),
("workspace", settings.id.workspace.as_str().to_string(),),
("group", settings.id.group.as_str().to_string(),),
],
)
);
Ok(service)
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolve_algorithm_rejects_unknown_and_uncompiled() {
assert!(resolve_algorithm("md5").is_err());
assert!(resolve_algorithm("snowflake").is_err());
assert_eq!(resolve_algorithm("uuid_v8").unwrap(), AlgorithmType::UuidV8);
assert!(
resolve_algorithm("uuid_v4").is_err(),
"rc.3 起 uuid_v4 为真算法(非 v8 别名),未编译时必须显性拒绝"
);
}
}