1use super::{
7 ActionContext, ActorContext, ApiResponse, SystemTenantCapability, TenantContext, TenantId, User,
8};
9use crate::error::BaseError;
10use crate::router::{Middleware, MiddlewareRole, Next};
11use async_trait::async_trait;
12
13pub const TENANT_ID_HEADER: &str = "x-tenant-id";
15
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
21pub enum TenantResolution {
22 Tenant(TenantContext),
24 System(SystemTenantCapability),
26}
27
28impl TenantResolution {
29 pub fn system_for(user: &User) -> Result<Self, BaseError> {
31 if !user.has_role("system") {
32 return Err(BaseError::PermissionDenied(
33 "只有已认证 system 角色可获授系统租户 capability".to_string(),
34 ));
35 }
36 Ok(Self::System(SystemTenantCapability::issue(
37 ActorContext::new(user.id),
38 )))
39 }
40}
41
42impl From<TenantContext> for TenantResolution {
43 fn from(value: TenantContext) -> Self {
44 Self::Tenant(value)
45 }
46}
47
48#[async_trait]
54pub trait TenantResolver: Send + Sync + 'static {
55 async fn resolve(
59 &self,
60 context: &ActionContext,
61 requested: Option<TenantId>,
62 ) -> Result<TenantResolution, BaseError>;
63
64 async fn resolve_with_context(
71 &self,
72 context: &mut ActionContext,
73 requested: Option<TenantId>,
74 ) -> Result<TenantResolution, BaseError> {
75 self.resolve(context, requested).await
76 }
77}
78
79pub struct TenantResolverMiddleware<R> {
88 resolver: R,
89}
90
91impl<R> TenantResolverMiddleware<R>
92where
93 R: TenantResolver,
94{
95 pub fn new(resolver: R) -> Self {
97 Self { resolver }
98 }
99}
100
101#[async_trait]
102impl<R> Middleware for TenantResolverMiddleware<R>
103where
104 R: TenantResolver,
105{
106 fn role(&self) -> MiddlewareRole {
107 MiddlewareRole::TenantResolution
108 }
109
110 async fn handle(
111 &self,
112 mut context: ActionContext,
113 next: Next<'_>,
114 ) -> Result<ApiResponse, BaseError> {
115 let requested = requested_tenant(&context)?;
116 let resolution = self
117 .resolver
118 .resolve_with_context(&mut context, requested)
119 .await?;
120 let context = match resolution {
121 TenantResolution::Tenant(tenant) => {
122 tracing::Span::current().record("tenant_scope", "tenant");
123 tracing::Span::current().record("tenant_id", tenant.id().get());
124 context.with_tenant(tenant)
125 }
126 TenantResolution::System(capability) => {
127 tracing::Span::current().record("tenant_scope", "system");
128 context.with_system_tenant(capability)
129 }
130 };
131 next.run(context).await
132 }
133}
134
135fn requested_tenant(context: &ActionContext) -> Result<Option<TenantId>, BaseError> {
136 let Some(raw) = context.request.get_header(TENANT_ID_HEADER) else {
137 return Ok(None);
138 };
139 let value = raw.parse::<i64>().map_err(|_| {
140 BaseError::ParamInvalid(
141 TENANT_ID_HEADER.to_string(),
142 "租户 ID 必须是正整数".to_string(),
143 )
144 })?;
145 if value <= 0 {
146 return Err(BaseError::ParamInvalid(
147 TENANT_ID_HEADER.to_string(),
148 "租户 ID 必须是正整数".to_string(),
149 ));
150 }
151 Ok(Some(TenantId::new(value)))
152}
153
154#[cfg(test)]
155mod tests {
156 use super::*;
157 use crate::action::{ContextKey, Request, TypedHandler, User};
158 use crate::definition::{
159 ActionName, ActionRef, ActionSpec, AddonName, AddonSpec, AppBuilder, HttpMethod,
160 ModuleName, ModuleSpec, RouteSpec,
161 };
162 use crate::tools::ToolsBuilder;
163 use async_trait::async_trait;
164 use schemars::JsonSchema;
165 use serde::{Deserialize, Serialize};
166 use std::sync::Arc;
167 use yang_base_derive::Action;
168
169 #[derive(Debug, Default, Deserialize, JsonSchema)]
170 #[serde(deny_unknown_fields)]
171 struct EmptyInput {}
172
173 #[derive(Debug, Serialize, JsonSchema)]
174 struct TenantProbeOutput {
175 tenant_id: Option<i64>,
176 system_actor_id: Option<i64>,
177 resolver_evidence: Option<i64>,
178 }
179
180 const RESOLVER_EVIDENCE: ContextKey<i64> = ContextKey::new("resolver_evidence");
181
182 #[derive(Action)]
183 #[action(name = "tenant_probe", display_name = "租户探针")]
184 struct TenantProbe;
185
186 #[async_trait]
187 impl TypedHandler for TenantProbe {
188 type Input = EmptyInput;
189 type Output = TenantProbeOutput;
190
191 async fn handle(
192 &self,
193 mut context: ActionContext,
194 _input: Self::Input,
195 ) -> Result<Self::Output, BaseError> {
196 let resolver_evidence = context.request_context().get(RESOLVER_EVIDENCE).copied();
197 match context.tenant() {
198 Ok(tenant) => Ok(TenantProbeOutput {
199 tenant_id: Some(tenant.id().get()),
200 system_actor_id: None,
201 resolver_evidence,
202 }),
203 Err(_) => Ok(TenantProbeOutput {
204 tenant_id: None,
205 system_actor_id: Some(context.system_tenant()?.actor().user_id()),
206 resolver_evidence,
207 }),
208 }
209 }
210 }
211
212 struct MembershipResolver;
213
214 #[async_trait]
215 impl TenantResolver for MembershipResolver {
216 async fn resolve(
217 &self,
218 context: &ActionContext,
219 requested: Option<TenantId>,
220 ) -> Result<TenantResolution, BaseError> {
221 let user = context
222 .authenticated_user()
223 .ok_or_else(|| BaseError::Unauthorized("租户解析需要已认证用户".to_string()))?;
224 if user.has_role("system") {
225 return TenantResolution::system_for(user);
226 }
227
228 let tenant = requested.unwrap_or_else(|| TenantId::new(10));
229 if user.id == 7 && tenant == TenantId::new(10) {
230 Ok(TenantContext::new(tenant).into())
231 } else {
232 Err(BaseError::PermissionDenied(format!(
233 "用户无权访问租户 {}",
234 tenant.get()
235 )))
236 }
237 }
238
239 async fn resolve_with_context(
240 &self,
241 context: &mut ActionContext,
242 requested: Option<TenantId>,
243 ) -> Result<TenantResolution, BaseError> {
244 let resolution = self.resolve(context, requested).await?;
245 if matches!(resolution, TenantResolution::Tenant(_)) {
246 context.request_context().insert(RESOLVER_EVIDENCE, 42);
247 }
248 Ok(resolution)
249 }
250 }
251
252 fn test_app() -> crate::definition::BuiltApp {
253 let module_name = ModuleName::new("org.tenant").expect("测试 Module 名称应有效");
254 let module = ModuleSpec::new(module_name)
255 .middleware(TenantResolverMiddleware::new(MembershipResolver))
256 .action(
257 ActionSpec::new(
258 ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
259 RouteSpec::new(
260 HttpMethod::Get,
261 "/api/v1/org/tenant/probe",
262 "org.tenant.tenant_probe",
263 ),
264 ),
265 TenantProbe,
266 );
267 let tools = Arc::new(ToolsBuilder::new().build().expect("测试 Tools 应构建成功"));
268 AppBuilder::new()
269 .addon(
270 AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
271 .module(module),
272 )
273 .build(tools)
274 .expect("租户解析测试应用应构建成功")
275 }
276
277 fn probe_handle(app: &crate::definition::BuiltApp) -> crate::definition::ActionHandle {
278 app.registry()
279 .resolve(&ActionRef::new(
280 ModuleName::new("org.tenant").expect("测试 Module 名称应有效"),
281 ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
282 ))
283 .expect("租户探针应已注册")
284 }
285
286 fn tenant_response(response: ApiResponse) -> (Option<i64>, Option<i64>) {
287 let data = response.data.expect("租户探针应返回 JSON data");
288 (
289 data.get("tenant_id").and_then(serde_json::Value::as_i64),
290 data.get("system_actor_id")
291 .and_then(serde_json::Value::as_i64),
292 )
293 }
294
295 async fn dispatch_as(
296 app: &crate::definition::BuiltApp,
297 request: Request,
298 user: Option<User>,
299 ) -> Result<ApiResponse, BaseError> {
300 let mut context = app.context(request);
301 if let Some(user) = user {
302 context = context.with_user(user);
303 }
304 app.dispatch_context(probe_handle(app), context).await
305 }
306
307 #[tokio::test]
308 async fn resolver_accepts_authorized_candidate_and_safe_default() {
309 let app = test_app();
310 let user = User::new(7, "member");
311
312 let selected = dispatch_as(
313 &app,
314 Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
315 Some(user.clone()),
316 )
317 .await
318 .expect("成员应能选择所属租户");
319 assert_eq!(
320 selected
321 .data
322 .as_ref()
323 .and_then(|data| data.get("resolver_evidence"))
324 .and_then(serde_json::Value::as_i64),
325 Some(42),
326 "resolver 同一次事实查询写入的请求 capability 必须到达后续 Action"
327 );
328 assert_eq!(tenant_response(selected), (Some(10), None));
329
330 let defaulted = dispatch_as(&app, Request::new(serde_json::json!({})), Some(user))
331 .await
332 .expect("resolver 应能安全选择服务端默认租户");
333 assert_eq!(tenant_response(defaulted), (Some(10), None));
334 }
335
336 #[tokio::test]
337 async fn resolver_rejects_invalid_cross_tenant_and_unauthenticated_requests() {
338 let app = test_app();
339 let user = User::new(7, "member");
340
341 for invalid in ["", "system", "0", "-1"] {
342 let result = dispatch_as(
343 &app,
344 Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, invalid),
345 Some(user.clone()),
346 )
347 .await;
348 assert!(matches!(
349 result,
350 Err(BaseError::ParamInvalid(field, _)) if field == TENANT_ID_HEADER
351 ));
352 }
353
354 let cross_tenant = dispatch_as(
355 &app,
356 Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "20"),
357 Some(user),
358 )
359 .await;
360 assert!(matches!(
361 cross_tenant,
362 Err(BaseError::PermissionDenied(message)) if message.contains("租户 20")
363 ));
364
365 let unauthenticated = dispatch_as(
366 &app,
367 Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
368 None,
369 )
370 .await;
371 assert!(matches!(unauthenticated, Err(BaseError::Unauthorized(_))));
372 }
373
374 #[tokio::test]
375 async fn system_context_can_only_come_from_trusted_resolver() {
376 let app = test_app();
377 let system_user = User::new(1, "root").with_roles(["system"]);
378 assert!(matches!(
379 TenantResolution::system_for(&User::new(7, "member")),
380 Err(BaseError::PermissionDenied(_))
381 ));
382
383 let response = dispatch_as(&app, Request::new(serde_json::json!({})), Some(system_user))
384 .await
385 .expect("系统角色应由可信 resolver 映射为 system 上下文");
386 assert_eq!(tenant_response(response), (None, Some(1)));
387
388 let forged = dispatch_as(
389 &app,
390 Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "system"),
391 Some(User::new(7, "member")),
392 )
393 .await;
394 assert!(matches!(
395 forged,
396 Err(BaseError::ParamInvalid(field, _)) if field == TENANT_ID_HEADER
397 ));
398 }
399
400 #[cfg(feature = "token")]
407 mod token_auth_chain {
408 use super::*;
409 use crate::action::TokenAuthMiddleware;
410
411 fn chain_tools() -> Arc<crate::tools::Tools> {
413 Arc::new(
414 ToolsBuilder::new()
415 .token(
416 crate::token::TokenManager::new_symmetric(
417 "tenant-chain-test-secretxxxxxxxx",
418 jsonwebtoken::Algorithm::HS256,
419 "test-issuer".to_string(),
420 "test-audience".to_string(),
421 3600,
422 7200,
423 )
424 .expect("测试 TokenManager 应构建成功"),
425 )
426 .build()
427 .expect("测试 Tools 应构建成功"),
428 )
429 }
430
431 fn chain_handle(
432 app: &crate::definition::BuiltApp,
433 module: &str,
434 action: &str,
435 ) -> crate::definition::ActionHandle {
436 app.registry()
437 .resolve(&ActionRef::new(
438 ModuleName::new(module).expect("测试 Module 名称应有效"),
439 ActionName::new(action).expect("测试 Action 名称应有效"),
440 ))
441 .expect("探针 Action 应已注册")
442 }
443
444 fn chain_access_token(app: &crate::definition::BuiltApp) -> String {
445 app.tools()
446 .token()
447 .expect("测试应用应配置 TokenManager")
448 .generate_access_token("user-7", serde_json::json!({}))
449 .expect("测试 Access Token 应生成成功")
450 }
451
452 fn protected_chain_app() -> crate::definition::BuiltApp {
454 let module = ModuleSpec::new(
455 ModuleName::new("org.tenant_chain").expect("测试 Module 名称应有效"),
456 )
457 .middleware(TokenAuthMiddleware::new(|claims| {
458 User::new(7, claims.sub.clone())
459 }))
460 .middleware(TenantResolverMiddleware::new(MembershipResolver))
461 .action(
462 ActionSpec::new(
463 ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
464 RouteSpec::new(
465 HttpMethod::Get,
466 "/api/v1/org/tenant-chain/probe",
467 "org.tenant_chain.tenant_probe",
468 ),
469 ),
470 TenantProbe,
471 );
472 AppBuilder::new()
473 .addon(
474 AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
475 .module(module),
476 )
477 .build(chain_tools())
478 .expect("链路测试应用应构建成功")
479 }
480
481 #[test]
482 fn build_rejects_tenant_before_token_authentication() {
483 let module = ModuleSpec::new(
484 ModuleName::new("org.tenant_bad_order").expect("测试 Module 名称应有效"),
485 )
486 .middleware(TenantResolverMiddleware::new(MembershipResolver))
487 .middleware(TokenAuthMiddleware::new(|claims| {
488 User::new(7, claims.sub.clone())
489 }))
490 .action(
491 ActionSpec::new(
492 ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
493 RouteSpec::new(
494 HttpMethod::Get,
495 "/api/v1/org/tenant-bad-order/probe",
496 "org.tenant_bad_order.tenant_probe",
497 ),
498 ),
499 TenantProbe,
500 );
501 let error = AppBuilder::new()
502 .addon(
503 AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
504 .module(module),
505 )
506 .build(chain_tools())
507 .expect_err("租户解析先于认证必须在构建期失败");
508 assert!(matches!(
509 error,
510 crate::definition::BuildError::InvalidReference {
511 kind: "Middleware order",
512 ..
513 }
514 ));
515 }
516
517 #[tokio::test]
519 async fn token_auth_runs_before_tenant_resolver_and_fails_closed() {
520 let app = protected_chain_app();
521 let handle = chain_handle(&app, "org.tenant_chain", "tenant_probe");
522
523 let missing = app
526 .dispatch(
527 handle,
528 Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
529 )
530 .await;
531 assert!(matches!(
532 missing,
533 Err(BaseError::Unauthorized(message)) if message.contains("Authorization Bearer Token")
534 ));
535
536 let invalid = app
538 .dispatch(
539 handle,
540 Request::new(serde_json::json!({}))
541 .header("Authorization", "Bearer invalid-token")
542 .header(TENANT_ID_HEADER, "10"),
543 )
544 .await;
545 assert!(matches!(invalid, Err(BaseError::TokenVerifyFailed(_))));
546
547 let token = chain_access_token(&app);
550 let no_store = app
551 .dispatch(
552 handle,
553 Request::new(serde_json::json!({}))
554 .header("Authorization", format!("Bearer {token}"))
555 .header(TENANT_ID_HEADER, "10"),
556 )
557 .await;
558 assert!(
559 matches!(no_store, Err(BaseError::RedisNotInitialized)),
560 "无撤销存储时不得降级放行: {no_store:?}"
561 );
562 }
563
564 #[derive(Debug, Serialize, JsonSchema)]
566 struct TenantAuthProbeOutput {
567 tenant_id: i64,
568 authenticated: bool,
569 }
570
571 #[derive(Action)]
572 #[action(name = "tenant_auth_probe", display_name = "租户认证探针", public)]
573 struct TenantAuthProbe;
574
575 #[async_trait]
576 impl TypedHandler for TenantAuthProbe {
577 type Input = EmptyInput;
578 type Output = TenantAuthProbeOutput;
579
580 async fn handle(
581 &self,
582 context: ActionContext,
583 _input: Self::Input,
584 ) -> Result<Self::Output, BaseError> {
585 let tenant = context.tenant()?;
586 Ok(TenantAuthProbeOutput {
587 tenant_id: tenant.id().get(),
588 authenticated: context.authenticated_user().is_some(),
589 })
590 }
591 }
592
593 struct GuestOrMemberResolver;
596
597 #[async_trait]
598 impl TenantResolver for GuestOrMemberResolver {
599 async fn resolve(
600 &self,
601 context: &ActionContext,
602 requested: Option<TenantId>,
603 ) -> Result<TenantResolution, BaseError> {
604 let Some(user) = context.authenticated_user() else {
605 return Ok(TenantContext::new(TenantId::new(1)).into());
606 };
607 let tenant = requested.unwrap_or_else(|| TenantId::new(10));
608 if user.id == 7 && tenant == TenantId::new(10) {
609 Ok(TenantContext::new(tenant).into())
610 } else {
611 Err(BaseError::PermissionDenied(format!(
612 "用户无权访问租户 {}",
613 tenant.get()
614 )))
615 }
616 }
617 }
618
619 fn public_chain_app() -> crate::definition::BuiltApp {
621 let module = ModuleSpec::new(
622 ModuleName::new("org.tenant_public").expect("测试 Module 名称应有效"),
623 )
624 .middleware(
625 TokenAuthMiddleware::new(|claims| User::new(7, claims.sub.clone()))
626 .authenticate_public_actions(),
627 )
628 .middleware(TenantResolverMiddleware::new(GuestOrMemberResolver))
629 .action(
630 ActionSpec::new(
631 ActionName::new("tenant_auth_probe").expect("测试 Action 名称应有效"),
632 RouteSpec::new(
633 HttpMethod::Get,
634 "/api/v1/org/tenant-public/probe",
635 "org.tenant_public.tenant_auth_probe",
636 ),
637 )
638 .public(true),
639 TenantAuthProbe,
640 );
641 AppBuilder::new()
642 .addon(
643 AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
644 .module(module),
645 )
646 .build(chain_tools())
647 .expect("三方组合测试应用应构建成功")
648 }
649
650 fn probe_observation(response: ApiResponse) -> (i64, bool) {
651 let data = response.data.expect("探针应返回 JSON data");
652 (
653 data.get("tenant_id")
654 .and_then(serde_json::Value::as_i64)
655 .expect("探针应返回 tenant_id"),
656 data.get("authenticated")
657 .and_then(serde_json::Value::as_bool)
658 .expect("探针应返回 authenticated 布尔值"),
659 )
660 }
661
662 #[tokio::test]
665 async fn public_action_with_optional_auth_and_tenant_middleware_compose() {
666 let app = public_chain_app();
667 let handle = chain_handle(&app, "org.tenant_public", "tenant_auth_probe");
668
669 let anonymous = app
672 .dispatch(
673 handle,
674 Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
675 )
676 .await
677 .expect("匿名请求应经可选认证放行并获得访客租户上下文");
678 assert_eq!(probe_observation(anonymous), (1, false));
679
680 let wrong_scheme = app
682 .dispatch(
683 handle,
684 Request::new(serde_json::json!({}))
685 .header("Authorization", "Basic credentials"),
686 )
687 .await;
688 assert!(matches!(
689 wrong_scheme,
690 Err(BaseError::Unauthorized(message)) if message.contains("Authorization Bearer Token")
691 ));
692
693 let invalid = app
695 .dispatch(
696 handle,
697 Request::new(serde_json::json!({}))
698 .header("Authorization", "Bearer invalid-token"),
699 )
700 .await;
701 assert!(matches!(invalid, Err(BaseError::TokenVerifyFailed(_))));
702
703 let token = chain_access_token(&app);
705 let no_store = app
706 .dispatch(
707 handle,
708 Request::new(serde_json::json!({}))
709 .header("Authorization", format!("Bearer {token}")),
710 )
711 .await;
712 assert!(
713 matches!(no_store, Err(BaseError::RedisNotInitialized)),
714 "无撤销存储时不得降级为匿名: {no_store:?}"
715 );
716 }
717 }
718}