@mtpc/rbac 深入技术分析与使用指南

packages/rbac/src/
├── types.ts              # 类型定义
├── rbac.ts               # RBAC 主类
├── plugin.ts             # MTPC 插件集成
├── role/                 # 角色管理
│   ├── manager.ts        # 角色管理器
│   ├── builder.ts        # 角色构建器
│   ├── validator.ts      # 输入验证
│   └── index.ts
├── binding/              # 角色绑定
│   ├── manager.ts        # 绑定管理器
│   ├── validator.ts      # 输入验证
│   └── index.ts
├── policy/               # 权限评估
│   ├── evaluator.ts      # 权限评估器
│   ├── compiler.ts       # 策略编译器
│   └── index.ts
└── store/                # 存储后端
    ├── memory-store.ts   # 内存存储实现
    └── index.ts

/**
 * 角色状态
 * - active: 角色处于活动状态
 * - inactive: 角色被停用
 * - archived: 角色已归档
 */
type RoleStatus = 'active' | 'inactive' | 'archived';
 
/**
 * 角色类型
 * - system: 系统预定义角色，不可修改和删除
 * - custom: 用户自定义角色
 * - template: 角色模板
 */
type RoleType = 'system' | 'custom' | 'template';

interface RoleDefinition {
  id: string;                    // 角色唯一标识符
  tenantId: string;              // 所属租户 ID
  name: string;                  // 角色名称（唯一）
  displayName?: string;           // 角色显示名称
  description?: string;           // 角色描述
  type: RoleType;                // 角色类型
  status: RoleStatus;             // 角色状态
  permissions: string[];         // 权限列表
  inherits?: string[];            // 继承的角色 ID 列表
  metadata?: Record<string, unknown>;  // 自定义元数据
  createdAt: Date;               // 创建时间
  updatedAt: Date;               // 更新时间
  createdBy?: string;            // 创建者 ID
}

/**
 * 主体类型
 * - user: 用户
 * - group: 用户组
 * - service: 服务
 */
type BindingSubjectType = 'user' | 'group' | 'service';
 
interface RoleBinding {
  id: string;                    // 绑定唯一标识符
  tenantId: string;              // 所属租户 ID
  roleId: string;                // 绑定的角色 ID
  subjectType: BindingSubjectType;  // 主体类型
  subjectId: string;             // 主体 ID
  expiresAt?: Date;              // 过期时间（未设置表示永久有效）
  metadata?: Record<string, unknown>;  // 自定义元数据
  createdAt: Date;               // 创建时间
  createdBy?: string;            // 创建者 ID
}

interface RBACCheckResult {
  allowed: boolean;               // 是否允许访问
  matchedRoles: string[];         // 授予该权限的所有角色 ID
  reason?: string;                // 人类可读的检查结果说明
}

interface EffectivePermissions {
  tenantId: string;              // 所属租户 ID
  subjectId: string;             // 主体 ID
  subjectType: BindingSubjectType;  // 主体类型
  roles: string[];               // 权限来源角色 ID 列表
  permissions: Set<string>;      // 有效权限集合
  computedAt: Date;              // 计算时间
  expiresAt?: Date;              // 缓存过期时间
}

import { createRBAC } from '@mtpc/rbac';
 
const rbac = createRBAC();
 
// 方式 1：使用 createRole 方法
const role = await rbac.createRole('tenant-001', {
  name: 'editor',
  displayName: 'Content Editor',
  description: 'Can edit and publish content',
  type: 'custom',
  status: 'active',
  permissions: ['content:read', 'content:write'],
  inherits: ['viewer'],
  metadata: { category: 'editorial' }
}, 'admin');
 
console.log(role.id);           // 自动生成的 ID
console.log(role.createdAt);     // 自动设置的时间戳

import { role } from '@mtpc/rbac';
 
// 方式 2：使用 RoleBuilder 流式 API
const input = role('editor')
  .displayName('Content Editor')
  .description('Can edit and publish content')
  .system()  // 或 .custom() / .template()
  .permissions('content:read', 'content:write')
  .inherit('viewer')
  .metadata({ category: 'editorial' })
  .build();
 
const role = await rbac.createRole('tenant-001', input);

// 创建基础角色
const viewer = await rbac.createRole('tenant-001', {
  name: 'viewer',
  displayName: 'Viewer',
  permissions: ['content:read']
});
 
// 创建继承 viewer 的 editor 角色
const editor = await rbac.createRole('tenant-001', {
  name: 'editor',
  displayName: 'Editor',
  permissions: ['content:write'],
  inherits: ['viewer']  // 继承 viewer 的权限
});
 
// 创建继承 editor 的 admin 角色
const admin = await rbac.createRole('tenant-001', {
  name: 'admin',
  displayName: 'Administrator',
  permissions: ['content:delete'],
  inherits: ['editor']  // 间接继承 viewer
});
 
// admin 将拥有所有权限：content:read, content:write, content:delete

const updated = await rbac.updateRole('tenant-001', 'role-id', {
  displayName: 'Senior Editor',
  status: 'active',
  permissions: ['content:read', 'content:write', 'content:publish'],
  inherits: ['viewer', 'reviewer']  // 完全替换继承关系
});
 
// 注意：系统角色不能被修改

const deleted = await rbac.deleteRole('tenant-001', 'role-id');
if (deleted) {
  console.log('角色已删除');
}
 
// 注意：
// 1. 系统角色不能被删除
// 2. 删除角色会自动删除所有相关绑定

// 根据 ID 获取角色
const role = await rbac.getRole('tenant-001', 'role-id');
 
// 列出所有角色
const allRoles = await rbac.listRoles('tenant-001');
 
// 列出活跃角色
const activeRoles = await rbac.roles.listRoles('tenant-001', {
  status: 'active'
});
 
// 列出自定义角色
const customRoles = await rbac.roles.listRoles('tenant-001', {
  type: 'custom'
});

// 添加单个权限
await rbac.roles.addPermission('tenant-001', 'role-id', 'content:publish');
 
// 移除权限
await rbac.roles.removePermission('tenant-001', 'role-id', 'content:delete');
 
// 设置权限（完全替换）
await rbac.roles.setPermissions('tenant-001', 'role-id', [
  'content:read',
  'content:write',
  'content:publish'
]);
 
// 获取角色权限（包含继承）
const permissions = await rbac.roles.getRolePermissions('tenant-001', 'role-id');
console.log(Array.from(permissions));

// 克隆现有角色
const cloned = await rbac.roles.cloneRole(
  'tenant-001',
  'editor',
  'senior_editor',  // 新角色名称
  'admin'        // 创建者
);
 
console.log(cloned.displayName);  // "Content Editor (Copy)"

// 永久分配
const binding = await rbac.assignRole(
  'tenant-001',
  'editor',
  'user',
  'user-123'
);
 
// 临时分配（30 天后过期）
const binding = await rbac.assignRole(
  'tenant-001',
  'editor',
  'user',
  'user-123',
  {
    expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
    createdBy: 'admin-456'
  }
);
 
console.log(binding.id);  // 自动生成的绑定 ID

// 撤销特定角色
const revoked = await rbac.revokeRole(
  'tenant-001',
  'editor',
  'user',
  'user-123'
);
 
if (revoked) {
  console.log('角色已撤销');
}

// 获取主体的所有角色
const bindings = await rbac.getSubjectRoles('tenant-001', 'user', 'user-123');
 
for (const binding of bindings) {
  console.log(`角色: ${binding.roleId}, 过期时间: ${binding.expiresAt}`);
}
 
// 检查主体是否有角色
const hasEditor = await rbac.hasRole('tenant-001', 'editor', 'user', 'user-123');
 
// 获取拥有特定角色的所有主体
const subjects = await rbac.bindings.getRoleSubjects('tenant-001', 'editor');
console.log(`有 ${subjects.length} 个主体拥有编辑角色`);

// 撤销所有角色
const count = await rbac.bindings.revokeAllRoles('tenant-001', 'user', 'user-123');
console.log(`撤销了 ${count} 个角色`);
 
// 清理过期绑定
const cleaned = await rbac.bindings.cleanupExpired('tenant-001');
console.log(`清理了 ${cleaned} 个过期绑定`);

// 设置新的过期时间
await rbac.bindings.setExpiration(
  'tenant-001',
  'binding-id',
  new Date(Date.now() + 60 * 24 * 60 * 1000)  // 60 天后过期
);
 
// 设置为永久有效
await rbac.bindings.setExpiration('tenant-001', 'binding-id', null);

import { createRBAC } from '@mtpc/rbac';
 
const rbac = createRBAC();
 
// 方式 1：使用 checkPermission 方法
const result = await rbac.checkPermission({
  tenant: { id: 'tenant-001', status: 'active' },
  subject: { id: 'user-123', type: 'user' },
  permission: 'content:write',
  resourceId: 'article-456'  // 可选，用于更细粒度的控制
});
 
console.log(result.allowed);      // true/false
console.log(result.matchedRoles);  // ['editor', 'admin']
console.log(result.reason);       // 'Granted by roles: editor, admin'

// 方式 2：使用 check 方法（便捷方法）
const result = await rbac.check(
  { id: 'tenant-001', status: 'active' },
  { id: 'user-123', type: 'user' },
  'content:write'
);
 
if (result.allowed) {
  console.log('允许执行操作');
} else {
  console.log(`权限不足: ${result.reason}`);
}

// 获取主体的所有有效权限
const effective = await rbac.getEffectivePermissions(
  'tenant-001',
  'user',
  'user-123'
);
 
console.log('权限来源角色:', effective.roles);
console.log('权限数量:', effective.permissions.size);
console.log('权限列表:', Array.from(effective.permissions));

// 以数组形式返回权限
const permissions = await rbac.getPermissions('tenant-001', 'user', 'user-123');
 
console.log(permissions);
// ['content:read', 'content:write', 'content:delete', ...]

// 检查是否拥有任意权限
const hasAny = await rbac.evaluator.hasAnyPermission(
  { tenant: { id: 'tenant-001' }, subject: { id: 'user-123', type: 'user' } },
  ['content:write', 'content:delete']
);
 
// 检查是否拥有所有权限
const hasAll = await rbac.evaluator.hasAllPermissions(
  { tenant: { id: 'tenant-001' }, subject: { id: 'user-123', type: 'user' } },
  ['content:read', 'content:write']
);

import { createRBAC } from '@mtpc/rbac';
 
// 默认缓存 TTL 为 1 分钟（60000ms）
const rbac = createRBAC();
 
// 自定义缓存 TTL
const rbac = createRBAC({
  cacheTTL: 300000  // 5 分钟
});

// 使特定用户的缓存失效
rbac.invalidateCache('tenant-001', 'user-123');
 
// 使整个租户的缓存失效
rbac.invalidateCache('tenant-001');
 
// 清空所有缓存
rbac.clearCache();

import { createMTPC } from '@mtpc/core';
import { createRBACPlugin } from '@mtpc/rbac';
 
// 创建 RBAC 插件
const rbacPlugin = createRBACPlugin({
  cacheTTL: 300000  // 5 分钟缓存
});
 
// 创建 MTPC 实例并集成
const mtpc = createMTPC({
  // 必须提供 defaultPermissionResolver
  defaultPermissionResolver: rbacPlugin.state.evaluator.getPermissions.bind(rbacPlugin.state.evaluator)
});
 
// 注册插件（可选，用于访问插件状态）
mtpc.use(rbacPlugin);
 
// 初始化
await mtpc.init();

// 通过插件状态访问 RBAC 功能
const rbac = mtpc.getPlugin('@mtpc/rbac');
if (rbac?.state) {
  const { roles, bindings, evaluator } = rbac.state;
  
  // 使用角色管理器
  await roles.createRole('tenant-001', {
    name: 'editor',
    permissions: ['content:read', 'content:write']
  });
  
  // 使用绑定管理器
  await bindings.assignRole('tenant-001', 'editor', 'user', 'user-123');
  
  // 使用权限评估器
  const result = await evaluator.check({
    tenant: { id: 'tenant-001' },
    subject: { id: 'user-123', type: 'user' },
    permission: 'content:write'
  });
}

interface RBACStore {
  // 角色管理
  createRole(tenantId: string, input: RoleCreateInput, createdBy?: string): Promise<RoleDefinition>;
  updateRole(tenantId: string, roleId: string, input: RoleUpdateInput): Promise<RoleDefinition | null>;
  deleteRole(tenantId: string, roleId: string): Promise<boolean>;
  getRole(tenantId: string, roleId: string): Promise<RoleDefinition | null>;
  getRoleByName(tenantId: string, name: string): Promise<RoleDefinition | null>;
  listRoles(tenantId: string, options?: { status?: RoleStatus; type?: RoleType }): Promise<RoleDefinition[]>;
  
  // 绑定管理
  createBinding(tenantId: string, input: RoleBindingCreateInput, createdBy?: string): Promise<RoleBinding>;
  deleteBinding(tenantId: string, bindingId: string): Promise<boolean>;
  getBinding(tenantId: string, bindingId: string): Promise<RoleBinding | null>;
  listBindings(tenantId: string, options?: { roleId?: string; subjectId?: string; subjectType?: BindingSubjectType }): Promise<RoleBinding[]>;
  getSubjectBindings(tenantId: string, subjectType: BindingSubjectType, subjectId: string): Promise<RoleBinding[]>;
  
  // 权限管理
  getEffectivePermissions(tenantId: string, subjectType: BindingSubjectType, subjectId: string): Promise<EffectivePermissions>;
  invalidatePermissions(tenantId: string, subjectId?: string): Promise<void>;
}

import { InMemoryRBACStore } from '@mtpc/rbac';
 
// 创建内存存储实例
const store = new InMemoryRBACStore();
 
// 使用内存存储创建 RBAC 实例
const rbac = createRBAC({ store });
 
// 内存存储特性：
// - 快速读写操作（O(1) 查找复杂度）
// - 自动生成唯一 ID
// - 自动添加时间戳
// - 支持角色继承的权限计算
// - 自动清理关联绑定
 
// 限制：
// - 数据不持久化（进程重启后丢失）
// - 不适合生产环境的大规模应用
// - 内存使用量随数据量线性增长

import { RBACStore } from '@mtpc/rbac';
 
class DatabaseRBACStore implements RBACStore {
  // 实现所有接口方法
  async createRole(tenantId: string, input: RoleCreateInput, createdBy?: string): Promise<RoleDefinition> {
    // 保存到数据库
    // ...
  }
  
  async getRole(tenantId: string, roleId: string): Promise<RoleDefinition | null> {
    // 从数据库获取
    // ...
  }
  
  // ... 实现其他方法
}
 
// 使用自定义存储
const rbac = createRBAC({
  store: new DatabaseRBACStore(),
  cacheTTL: 300000
});

{
  id: 'super_admin',
  name: 'super_admin',
  displayName: 'Super Administrator',
  description: 'Full system access',
  type: 'system',
  status: 'active',
  permissions: ['*'],  // 通配符权限
  inherits: []
}

{
  id: 'tenant_admin',
  name: 'tenant_admin',
  displayName: 'Tenant Administrator',
  description: 'Full tenant access',
  type: 'system',
  status: 'active',
  permissions: [],  // 注意：实际实现中是空数组
  inherits: []
}

{
  id: 'viewer',
  name: 'viewer',
  displayName: 'Viewer',
  description: 'Read-only access',
  type: 'system',
  status: 'active',
  permissions: [],  // 空权限
  inherits: []
}

import { createRBAC, systemRoles } from '@mtpc/rbac';
 
// 创建自定义系统角色
const customSuperAdmin = systemRoles.superAdmin()
  .displayName('Custom Super Admin')
  .buildDefinition('custom_super_admin');
 
const rbac = createRBAC({
  systemRoles: [customSuperAdmin]
});

interface RBACOptions {
  /**
   * 自定义存储后端
   * 未指定则使用内存存储
   */
  store?: RBACStore;
  
  /**
   * 缓存生存时间（毫秒）
   * 默认 60000（1 分钟）
   */
  cacheTTL?: number;
  
  /**
   * 自定义系统角色
   * 未指定则使用默认系统角色
   */
  systemRoles?: RoleDefinition[];
  
  /**
   * 自定义权限解析器
   * 用于从外部获取额外权限
   */
  permissionResolver?: (tenantId: string, subjectId: string) => Promise<Set<string>>;
}

interface RoleCreateInput {
  /**
   * 角色名称
   * 2-50 字符，以字母开头
   * 仅包含字母、数字、下划线和连字符
   */
  name: string;
  
  /**
   * 角色显示名称
   * 最多 100 字符
   */
  displayName?: string;
  
  /**
   * 角色描述
   * 最多 500 字符
   */
  description?: string;
  
  /**
   * 角色类型
   * 默认为 'custom'
   */
  type?: RoleType;
  
  /**
   * 权限列表
   * 默认为空数组
   */
  permissions?: string[];
  
  /**
   * 继承的角色 ID 列表
   */
  inherits?: string[];
  
  /**
   * 自定义元数据
   */
  metadata?: Record<string, unknown>;
}

interface RoleUpdateInput {
  /**
   * 角色显示名称
   */
  displayName?: string;
  
  /**
   * 角色描述
   */
  description?: string;
  
  /**
   * 角色状态
   */
  status?: RoleStatus;
  
  /**
   * 权限列表
   * 完全替换现有权限
   */
  permissions?: string[];
  
  /**
   * 继承的角色 ID 列表
   * 完全替换现有继承关系
   */
  inherits?: string[];
  
  /**
   * 自定义元数据
   * 会与现有元数据合并
   */
  metadata?: Record<string, unknown>;
}

interface RoleBindingCreateInput {
  /**
   * 要绑定的角色 ID
   */
  roleId: string;
  
  /**
   * 主体类型
   * 'user' | 'group' | 'service'
   */
  subjectType: BindingSubjectType;
  
  /**
   * 主体 ID
   */
  subjectId: string;
  
  /**
   * 过期时间
   * 必须是未来的时间
   */
  expiresAt?: Date;
  
  /**
   * 自定义元数据
   */
  metadata?: Record<string, unknown>;
}

interface RBACCheckContext {
  /**
   * 租户上下文
   */
  tenant: TenantContext;
  
  /**
   * 主体上下文
   */
  subject: SubjectContext;
  
  /**
   * 要检查的权限
   */
  permission: string;
  
  /**
   * 资源 ID
   * 可选，用于更细粒度的权限控制
   */
  resourceId?: string;
}

import { createRBAC } from '@mtpc/rbac';
 
// 创建 RBAC 实例
const rbac = createRBAC({
  cacheTTL: 300000  // 5 分钟缓存
});
 
// ========== 角色管理 ==========
 
// 创建基础角色
const viewer = await rbac.createRole('tenant-001', {
  name: 'viewer',
  displayName: 'Viewer',
  description: 'Read-only access',
  permissions: ['content:read', 'article:read']
});
 
// 创建编辑角色，继承 viewer
const editor = await rbac.createRole('tenant-001', {
  name: 'editor',
  displayName: 'Editor',
  description: 'Can create and edit content',
  permissions: ['content:write', 'article:write'],
  inherits: ['viewer']
});
 
// 创建管理员角色，继承 editor
const admin = await rbac.createRole('tenant-001', {
  name: 'admin',
  displayName: 'Administrator',
  description: 'Full access',
  permissions: ['content:delete', 'article:delete'],
  inherits: ['editor']
});
 
// ========== 角色绑定 ==========
 
// 分配角色给用户
await rbac.assignRole('tenant-001', 'viewer', 'user', 'user-001');
await rbac.assignRole('tenant-001', 'editor', 'user', 'user-002');
await rbac.assignRole('tenant-001', 'admin', 'user', 'user-003');
 
// 临时分配编辑角色（30 天后过期）
await rbac.assignRole('tenant-001', 'editor', 'user', 'user-001', {
  expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
  createdBy: 'admin-003'
});
 
// ========== 权限检查 ==========
 
// 检查权限
const result1 = await rbac.check(
  { id: 'tenant-001', status: 'active' },
  { id: 'user-002', type: 'user' },
  'content:write'
);
console.log('用户 002 可以写入内容:', result1.allowed);  // true
 
const result2 = await rbac.check(
  { id: 'tenant-001', status: 'active' },
  { id: 'user-001', type: 'user' },
  'content:delete'
);
console.log('用户 001 可以删除内容:', result2.allowed);  // false
 
// ========== 获取有效权限 ==========
 
const permissions = await rbac.getEffectivePermissions('tenant-001', 'user', 'user-003');
console.log('用户 003 的权限:', Array.from(permissions.permissions));
console.log('权限来源角色:', permissions.roles);
 
// ========== 批量操作 ==========
 
// 批量创建角色
const roles = [
  { name: 'reviewer', displayName: 'Reviewer', permissions: ['content:review'] },
  { name: 'publisher', displayName: 'Publisher', permissions: ['content:publish'] }
];
 
for (const role of roles) {
  await rbac.createRole('tenant-001', role);
}
 
// 批量分配角色
const assignments = [
  { role: 'reviewer', userId: 'user-004' },
  { role: 'publisher', userId: 'user-005' }
];
 
for (const assignment of assignments) {
  await rbac.assignRole('tenant-001', assignment.role, 'user', assignment.userId);
}

import { createMTPC } from '@mtpc/core';
import { createRBACPlugin } from '@mtpc/rbac';
 
// 创建 RBAC 插件
const rbacPlugin = createRBACPlugin({
  cacheTTL: 300000
});
 
// 创建 MTPC 实例
const mtpc = createMTPC({
  defaultPermissionResolver: rbacPlugin.state.evaluator.getPermissions.bind(rbacPlugin.state.evaluator)
});
 
// 注册插件
mtpc.use(rbacPlugin);
 
// 初始化
await mtpc.init();
 
// 使用 MTPC 进行权限检查
const result = await mtpc.checkPermission({
  tenant: { id: 'tenant-001', status: 'active' },
  subject: { id: 'user-123', type: 'user' },
  resource: 'content',
  action: 'write'
});
 
console.log('权限检查结果:', result);
 
// 访问 RBAC 功能
const rbac = mtpc.getPlugin('@mtpc/rbac');
if (rbac?.state) {
  // 创建新角色
  const role = await rbac.state.roles.createRole('tenant-001', {
    name: 'moderator',
    permissions: ['content:moderate']
  });
  
  // 分配角色
  await rbac.state.bindings.assignRole('tenant-001', 'moderator', 'user', 'user-456');
}

import { createRBAC, role } from '@mtpc/rbac';
 
const rbac = createRBAC();
 
// 使用 RoleBuilder 创建角色
const roleInput = role('content_manager')
  .displayName('Content Manager')
  .description('Manages all content operations')
  .type('custom')
  .fullAccess('content')  // 生成 content:create, content:read, content:update, content:delete, content:list
  .inherit('viewer')
  .metadata({ level: 'manager', department: 'content' })
  .build();
 
const role = await rbac.createRole('tenant-001', roleInput);
 
// 使用预定义资源权限方法
const readOnlyInput = role('content_reader')
  .displayName('Content Reader')
  .readOnly('content')  // 生成 content:read, content:list
  .build();
 
const readOnlyRole = await rbac.createRole('tenant-001', readOnlyInput);

import { createRBAC, RBACStore } from '@mtpc/rbac';
 
class DatabaseRBACStore implements RBACStore {
  private db: any;  // 假设的数据库连接
  
  constructor(db: any) {
    this.db = db;
  }
  
  async createRole(tenantId: string, input: RoleCreateInput, createdBy?: string): Promise<RoleDefinition> {
    const now = new Date();
    const role = {
      id: `role_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
      tenantId,
      ...input,
      type: input.type ?? 'custom',
      status: 'active',
      permissions: input.permissions ?? [],
      createdAt: now,
      updatedAt: now,
      createdBy
    };
    
    await this.db.roles.insert(role);
    return role;
  }
  
  async getRole(tenantId: string, roleId: string): Promise<RoleDefinition | null> {
    const role = await this.db.roles.findOne({ id: roleId, tenantId });
    return role || null;
  }
  
  // ... 实现其他方法
}
 
// 使用自定义存储
const db = new Database();  // 假设的数据库连接
const rbac = createRBAC({
  store: new DatabaseRBACStore(db),
  cacheTTL: 300000
});

import { checkCircularInheritance } from '@mtpc/rbac';
 
// 检查循环继承
const hasCircular = await checkCircularInheritance(
  async (id) => await rbac.getRole('tenant-001', id),
  'role-001',
  ['role-002', 'role-003']
);
 
if (hasCircular) {
  throw new Error('Circular inheritance detected');
}

// 删除角色会自动删除相关绑定
const deleted = await rbac.deleteRole('tenant-001', 'role-id');
 
// 检查角色是否存在
const role = await rbac.getRole('tenant-001', 'role-id');
console.log(role);  // null

const result = await rbac.checkPermission({
  tenant: { id: 'tenant-001', status: 'active' },
  subject: { id: 'user-123', type: 'user' },
  permission: 'content:delete',
  resourceId: 'article-456'
});
 
// 结合业务逻辑进行额外检查
if (result.allowed) {
  const article = await getArticle('article-456');
  if (article.authorId !== 'user-123') {
    console.log('只能删除自己的文章');
    result.allowed = false;
  }
}

// 方式 1：作为库集成到每个服务
import { createRBAC } from '@mtpc/rbac';
 
const rbac = createRBAC({
  store: new DatabaseRBACStore(sharedDbConnection),
  cacheTTL: 300000
});
 
// 方式 2：通过 API 网关集中管理
// 所有服务通过 API 调用检查权限

// 使用数据库存储
const rbac = createRBAC({
  store: new PostgreSQLRBACStore({
    host: 'localhost',
    port: 5432,
    database: 'mtpc',
    user: 'mtpc',
    password: 'password'
  }),
  cacheTTL: 60000
});
 
// 分页查询
const roles = await rbac.roles.listRoles('tenant-001');
const pageSize = 50;
for (let i = 0; i < roles.length; i += pageSize) {
  const page = roles.slice(i, i + pageSize);
  // 处理每页角色
}

import { createMTPC } from '@mtpc/core';
import { createRBACPlugin } from '@mtpc/rbac';
 
// 创建 RBAC 插件
const rbacPlugin = createRBACPlugin();
const mtpc = createMTPC({
  defaultPermissionResolver: rbacPlugin.state.evaluator.getPermissions.bind(rbacPlugin.state.evaluator)
});
 
// 注册策略
mtpc.registerPolicy({
  id: 'time-based',
  name: 'Time-based Access',
  rules: [{
    permissions: ['content:write'],
    effect: 'allow',
    conditions: [{
      type: 'time',
      operator: 'between',
      value: { start: '09:00', end: '18:00' }
    }]
  }]
});
 
await mtpc.init();
 
// 检查权限，结合 RBAC 和策略
const result = await mtpc.checkPermission({
  tenant: { id: 'tenant-001', status: 'active' },
  subject: { id: 'user-123', type: 'user' },
  resource: 'content',
  action: 'write'
});

// 优化缓存 TTL
const rbac = createRBAC({
  cacheTTL: 60000  // 1 分钟，根据实际情况调整
});
 
// 批量检查权限
const permissions = ['content:read', 'content:write', 'content:delete'];
const results = await Promise.all(
  permissions.map(perm => 
    rbac.check(
      { id: 'tenant-001', status: 'active' },
      { id: 'user-123', type: 'user' },
      perm
    )
  )
);
 
// 避免过深的继承层级
// viewer -> editor -> reviewer -> publisher -> admin (避免)
// viewer -> editor -> admin (推荐)

// 方式 1：使用 MTPC 钩子
import { createMTPC } from '@mtpc/core';
 
const mtpc = createMTPC({
  // ...
});
 
mtpc.registerGlobalHooks({
  afterAny: async (context, operation, resource, result) => {
    await auditLogger.log({
      userId: context.subject.id,
      tenantId: context.tenant.id,
      operation,
      resource,
      result,
      timestamp: new Date()
    });
  }
});
 
// 方式 2：在 RBAC 操作后记录
await rbac.assignRole('tenant-001', 'editor', 'user', 'user-123');
await auditLogger.log({
  action: 'assign_role',
  tenantId: 'tenant-001',
  userId: 'user-123',
  roleId: 'editor',
  timestamp: new Date()
});

import { createRBAC } from '@mtpc/rbac';
 
const rbac = createRBAC();
 
try {
  // 创建角色
  const role = await rbac.createRole('tenant-001', {
    name: 'editor',
    displayName: 'Content Editor',
    permissions: ['content:read', 'content:write']
  });
  
  // 分配角色
  await rbac.assignRole('tenant-001', 'editor', 'user', 'user-123');
  
  // 检查权限
  const result = await rbac.check(
    { id: 'tenant-001', status: 'active' },
    { id: 'user-123', type: 'user' },
    'content:write'
  );
  
  if (result.allowed) {
    console.log('权限允许');
  } else {
    console.log('权限拒绝:', result.reason);
  }
} catch (error) {
  if (error.message.includes('already exists')) {
    console.error('角色名称已存在');
  } else if (error.message.includes('Cannot modify system roles')) {
    console.error('不能修改系统角色');
  } else {
    console.error('未知错误:', error.message);
  }
}

import { createRBAC } from '@mtpc/rbac';
 
const rbac = createRBAC({
  cacheTTL: 60000
});
 
// 监控权限检查性能
const originalCheck = rbac.checkPermission.bind(rbac);
rbac.checkPermission = async (context) => {
  const startTime = performance.now();
  const result = await originalCheck(context);
  const endTime = performance.now();
  const duration = endTime - startTime;
  
  // 记录性能指标
  console.log('权限检查性能:', {
    permission: `${context.tenant.id}:${context.subject.id}:${context.permission}`,
    duration: `${duration.toFixed(2)}ms`,
    allowed: result.allowed
  });
  
  // 如果性能超过阈值，记录详细信息
  if (duration > 100) {
    console.warn('权限检查性能警告:', {
      ...context,
      duration: `${duration.toFixed(2)}ms`
    });
  }
  
  return result;
};