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(crate::token::TokenManager::new_symmetric(
416 "tenant-chain-test-secret",
417 jsonwebtoken::Algorithm::HS256,
418 "test-issuer".to_string(),
419 "test-audience".to_string(),
420 3600,
421 7200,
422 ))
423 .build()
424 .expect("测试 Tools 应构建成功"),
425 )
426 }
427
428 fn chain_handle(
429 app: &crate::definition::BuiltApp,
430 module: &str,
431 action: &str,
432 ) -> crate::definition::ActionHandle {
433 app.registry()
434 .resolve(&ActionRef::new(
435 ModuleName::new(module).expect("测试 Module 名称应有效"),
436 ActionName::new(action).expect("测试 Action 名称应有效"),
437 ))
438 .expect("探针 Action 应已注册")
439 }
440
441 fn chain_access_token(app: &crate::definition::BuiltApp) -> String {
442 app.tools()
443 .token()
444 .expect("测试应用应配置 TokenManager")
445 .generate_access_token("user-7", serde_json::json!({}))
446 .expect("测试 Access Token 应生成成功")
447 }
448
449 fn protected_chain_app() -> crate::definition::BuiltApp {
451 let module = ModuleSpec::new(
452 ModuleName::new("org.tenant_chain").expect("测试 Module 名称应有效"),
453 )
454 .middleware(TokenAuthMiddleware::new(|claims| {
455 User::new(7, claims.sub.clone())
456 }))
457 .middleware(TenantResolverMiddleware::new(MembershipResolver))
458 .action(
459 ActionSpec::new(
460 ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
461 RouteSpec::new(
462 HttpMethod::Get,
463 "/api/v1/org/tenant-chain/probe",
464 "org.tenant_chain.tenant_probe",
465 ),
466 ),
467 TenantProbe,
468 );
469 AppBuilder::new()
470 .addon(
471 AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
472 .module(module),
473 )
474 .build(chain_tools())
475 .expect("链路测试应用应构建成功")
476 }
477
478 #[test]
479 fn build_rejects_tenant_before_token_authentication() {
480 let module = ModuleSpec::new(
481 ModuleName::new("org.tenant_bad_order").expect("测试 Module 名称应有效"),
482 )
483 .middleware(TenantResolverMiddleware::new(MembershipResolver))
484 .middleware(TokenAuthMiddleware::new(|claims| {
485 User::new(7, claims.sub.clone())
486 }))
487 .action(
488 ActionSpec::new(
489 ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
490 RouteSpec::new(
491 HttpMethod::Get,
492 "/api/v1/org/tenant-bad-order/probe",
493 "org.tenant_bad_order.tenant_probe",
494 ),
495 ),
496 TenantProbe,
497 );
498 let error = AppBuilder::new()
499 .addon(
500 AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
501 .module(module),
502 )
503 .build(chain_tools())
504 .expect_err("租户解析先于认证必须在构建期失败");
505 assert!(matches!(
506 error,
507 crate::definition::BuildError::InvalidReference {
508 kind: "Middleware order",
509 ..
510 }
511 ));
512 }
513
514 #[tokio::test]
516 async fn token_auth_runs_before_tenant_resolver_and_fails_closed() {
517 let app = protected_chain_app();
518 let handle = chain_handle(&app, "org.tenant_chain", "tenant_probe");
519
520 let missing = app
523 .dispatch(
524 handle,
525 Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
526 )
527 .await;
528 assert!(matches!(
529 missing,
530 Err(BaseError::Unauthorized(message)) if message.contains("Authorization Bearer Token")
531 ));
532
533 let invalid = app
535 .dispatch(
536 handle,
537 Request::new(serde_json::json!({}))
538 .header("Authorization", "Bearer invalid-token")
539 .header(TENANT_ID_HEADER, "10"),
540 )
541 .await;
542 assert!(matches!(invalid, Err(BaseError::TokenVerifyFailed(_))));
543
544 let token = chain_access_token(&app);
547 let no_store = app
548 .dispatch(
549 handle,
550 Request::new(serde_json::json!({}))
551 .header("Authorization", format!("Bearer {token}"))
552 .header(TENANT_ID_HEADER, "10"),
553 )
554 .await;
555 assert!(
556 matches!(no_store, Err(BaseError::RedisNotInitialized)),
557 "无撤销存储时不得降级放行: {no_store:?}"
558 );
559 }
560
561 #[derive(Debug, Serialize, JsonSchema)]
563 struct TenantAuthProbeOutput {
564 tenant_id: i64,
565 authenticated: bool,
566 }
567
568 #[derive(Action)]
569 #[action(name = "tenant_auth_probe", display_name = "租户认证探针", public)]
570 struct TenantAuthProbe;
571
572 #[async_trait]
573 impl TypedHandler for TenantAuthProbe {
574 type Input = EmptyInput;
575 type Output = TenantAuthProbeOutput;
576
577 async fn handle(
578 &self,
579 context: ActionContext,
580 _input: Self::Input,
581 ) -> Result<Self::Output, BaseError> {
582 let tenant = context.tenant()?;
583 Ok(TenantAuthProbeOutput {
584 tenant_id: tenant.id().get(),
585 authenticated: context.authenticated_user().is_some(),
586 })
587 }
588 }
589
590 struct GuestOrMemberResolver;
593
594 #[async_trait]
595 impl TenantResolver for GuestOrMemberResolver {
596 async fn resolve(
597 &self,
598 context: &ActionContext,
599 requested: Option<TenantId>,
600 ) -> Result<TenantResolution, BaseError> {
601 let Some(user) = context.authenticated_user() else {
602 return Ok(TenantContext::new(TenantId::new(1)).into());
603 };
604 let tenant = requested.unwrap_or_else(|| TenantId::new(10));
605 if user.id == 7 && tenant == TenantId::new(10) {
606 Ok(TenantContext::new(tenant).into())
607 } else {
608 Err(BaseError::PermissionDenied(format!(
609 "用户无权访问租户 {}",
610 tenant.get()
611 )))
612 }
613 }
614 }
615
616 fn public_chain_app() -> crate::definition::BuiltApp {
618 let module = ModuleSpec::new(
619 ModuleName::new("org.tenant_public").expect("测试 Module 名称应有效"),
620 )
621 .middleware(
622 TokenAuthMiddleware::new(|claims| User::new(7, claims.sub.clone()))
623 .authenticate_public_actions(),
624 )
625 .middleware(TenantResolverMiddleware::new(GuestOrMemberResolver))
626 .action(
627 ActionSpec::new(
628 ActionName::new("tenant_auth_probe").expect("测试 Action 名称应有效"),
629 RouteSpec::new(
630 HttpMethod::Get,
631 "/api/v1/org/tenant-public/probe",
632 "org.tenant_public.tenant_auth_probe",
633 ),
634 )
635 .public(true),
636 TenantAuthProbe,
637 );
638 AppBuilder::new()
639 .addon(
640 AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
641 .module(module),
642 )
643 .build(chain_tools())
644 .expect("三方组合测试应用应构建成功")
645 }
646
647 fn probe_observation(response: ApiResponse) -> (i64, bool) {
648 let data = response.data.expect("探针应返回 JSON data");
649 (
650 data.get("tenant_id")
651 .and_then(serde_json::Value::as_i64)
652 .expect("探针应返回 tenant_id"),
653 data.get("authenticated")
654 .and_then(serde_json::Value::as_bool)
655 .expect("探针应返回 authenticated 布尔值"),
656 )
657 }
658
659 #[tokio::test]
662 async fn public_action_with_optional_auth_and_tenant_middleware_compose() {
663 let app = public_chain_app();
664 let handle = chain_handle(&app, "org.tenant_public", "tenant_auth_probe");
665
666 let anonymous = app
669 .dispatch(
670 handle,
671 Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
672 )
673 .await
674 .expect("匿名请求应经可选认证放行并获得访客租户上下文");
675 assert_eq!(probe_observation(anonymous), (1, false));
676
677 let wrong_scheme = app
679 .dispatch(
680 handle,
681 Request::new(serde_json::json!({}))
682 .header("Authorization", "Basic credentials"),
683 )
684 .await;
685 assert!(matches!(
686 wrong_scheme,
687 Err(BaseError::Unauthorized(message)) if message.contains("Authorization Bearer Token")
688 ));
689
690 let invalid = app
692 .dispatch(
693 handle,
694 Request::new(serde_json::json!({}))
695 .header("Authorization", "Bearer invalid-token"),
696 )
697 .await;
698 assert!(matches!(invalid, Err(BaseError::TokenVerifyFailed(_))));
699
700 let token = chain_access_token(&app);
702 let no_store = app
703 .dispatch(
704 handle,
705 Request::new(serde_json::json!({}))
706 .header("Authorization", format!("Bearer {token}")),
707 )
708 .await;
709 assert!(
710 matches!(no_store, Err(BaseError::RedisNotInitialized)),
711 "无撤销存储时不得降级为匿名: {no_store:?}"
712 );
713 }
714 }
715}