// 権限定義（型安全）
const PERMISSIONS = {
  // 記事
  'articles:read': '記事の閲覧',
  'articles:create': '記事の作成',
  'articles:update': '記事の編集',
  'articles:delete': '記事の削除',
  'articles:publish': '記事の公開',
  // ユーザー
  'users:read': 'ユーザー一覧',
  'users:create': 'ユーザー作成',
  'users:update': 'ユーザー編集',
  'users:delete': 'ユーザー削除',
  'users:invite': 'ユーザー招待',
  // 組織
  'org:settings': '組織設定',
  'org:billing': '課金管理',
  'org:members': 'メンバー管理',
} as const;
 
type Permission = keyof typeof PERMISSIONS;
 
// ロール定義（階層付き）
interface RoleConfig {
  description: string;
  permissions: Permission[];
  inherits: string[];
}
 
const ROLES: Record<string, RoleConfig> = {
  viewer: {
    description: '閲覧のみ',
    permissions: ['articles:read'],
    inherits: [],
  },
  editor: {
    description: '記事の作成・編集',
    permissions: ['articles:create', 'articles:update'],
    inherits: ['viewer'],
  },
  publisher: {
    description: '記事の公開・削除',
    permissions: ['articles:publish', 'articles:delete'],
    inherits: ['editor'],
  },
  admin: {
    description: 'ユーザー・組織管理',
    permissions: [
      'users:read', 'users:create', 'users:update',
      'users:delete', 'users:invite', 'org:settings', 'org:members',
    ],
    inherits: ['publisher'],
  },
  super_admin: {
    description: '全権限（課金含む）',
    permissions: ['org:billing'],
    inherits: ['admin'],
  },
};
 
type Role = keyof typeof ROLES;

// ロールの全権限を再帰的に解決
function resolvePermissions(role: string, visited = new Set<string>()): Set<Permission> {
  // 循環参照の防止
  if (visited.has(role)) return new Set();
  visited.add(role);
 
  const roleConfig = ROLES[role];
  if (!roleConfig) return new Set();
 
  const permissions = new Set<Permission>();
 
  // 直接の権限を追加
  roleConfig.permissions.forEach((p) => permissions.add(p));
 
  // 継承された権限を再帰的に解決
  roleConfig.inherits.forEach((parentRole) => {
    resolvePermissions(parentRole, visited).forEach((p) => permissions.add(p));
  });
 
  return permissions;
}
 
// 権限チェック
function hasPermission(userRole: string, permission: Permission): boolean {
  const permissions = resolvePermissions(userRole);
  return permissions.has(permission);
}
 
// ワイルドカード対応の権限チェック
function hasPermissionWithWildcard(
  userRole: string,
  requiredPermission: string
): boolean {
  const permissions = resolvePermissions(userRole);
 
  // 完全一致
  if (permissions.has(requiredPermission as Permission)) return true;
 
  // ワイルドカードチェック: users:* → users:read, users:create, ...
  const [resource] = requiredPermission.split(':');
  const wildcardPerm = `${resource}:*` as Permission;
  if (permissions.has(wildcardPerm)) return true;
 
  // 全権限ワイルドカード
  if (permissions.has('*:*' as Permission)) return true;
 
  return false;
}
 
// 使用例
console.log(hasPermission('editor', 'articles:read'));     // true（viewer から継承）
console.log(hasPermission('editor', 'articles:create'));   // true（直接の権限）
console.log(hasPermission('editor', 'articles:publish'));  // false（publisher 以上）
console.log(hasPermission('admin', 'articles:publish'));   // true（publisher から継承）
console.log(hasPermission('super_admin', 'org:billing'));  // true（直接の権限）

// schema.prisma
 
// model User {
//   id        String     @id @default(cuid())
//   email     String     @unique
//   name      String
//   password  String?
//   roles     UserRole[]
//   createdAt DateTime   @default(now())
//   updatedAt DateTime   @updatedAt
// }
//
// model Role {
//   id          String           @id @default(cuid())
//   name        String           @unique  // "admin", "editor", etc.
//   description String?
//   permissions RolePermission[]
//   users       UserRole[]
//   parentId    String?          // 階層ロール
//   parent      Role?            @relation("RoleHierarchy", fields: [parentId], references: [id])
//   children    Role[]           @relation("RoleHierarchy")
//   createdAt   DateTime         @default(now())
// }
//
// model Permission {
//   id          String           @id @default(cuid())
//   name        String           @unique  // "articles:read"
//   description String?
//   roles       RolePermission[]
//   createdAt   DateTime         @default(now())
// }
//
// model UserRole {
//   userId    String
//   roleId    String
//   user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
//   role      Role     @relation(fields: [roleId], references: [id], onDelete: Cascade)
//   assignedAt DateTime @default(now())
//   assignedBy String?  // 誰がこのロールを割当てたか
//   @@id([userId, roleId])
//   @@index([userId])
//   @@index([roleId])
// }
//
// model RolePermission {
//   roleId       String
//   permissionId String
//   role         Role       @relation(fields: [roleId], references: [id], onDelete: Cascade)
//   permission   Permission @relation(fields: [permissionId], references: [id], onDelete: Cascade)
//   @@id([roleId, permissionId])
// }

// DB からユーザーの全権限を取得（階層ロール対応）
async function getUserPermissions(userId: string): Promise<Set<string>> {
  const user = await prisma.user.findUnique({
    where: { id: userId },
    include: {
      roles: {
        include: {
          role: {
            include: {
              permissions: {
                include: { permission: true },
              },
              parent: {
                include: {
                  permissions: {
                    include: { permission: true },
                  },
                  // 2段階まで（深い階層は再帰で解決）
                  parent: {
                    include: {
                      permissions: {
                        include: { permission: true },
                      },
                    },
                  },
                },
              },
            },
          },
        },
      },
    },
  });
 
  const permissions = new Set<string>();
 
  // 全ロールの権限を収集（階層込み）
  function collectPermissions(role: any) {
    role.permissions.forEach(({ permission }: any) => {
      permissions.add(permission.name);
    });
 
    // 親ロールの権限も収集（再帰）
    if (role.parent) {
      collectPermissions(role.parent);
    }
  }
 
  user?.roles.forEach(({ role }) => collectPermissions(role));
 
  return permissions;
}
 
// 非正規化版（シンプル・高速）
async function getUserPermissionsSimple(userId: string): Promise<Set<string>> {
  const user = await prisma.user.findUnique({
    where: { id: userId },
    select: { role: true }, // role カラムが1つの場合
  });
 
  if (!user) return new Set();
 
  // コード定義のロールから権限を解決
  return resolvePermissions(user.role);
}

// Express ミドルウェア（汎用的な権限チェック）
import { Request, Response, NextFunction } from 'express';
 
// 権限チェックミドルウェア
function requirePermission(...requiredPermissions: string[]) {
  return async (req: Request, res: Response, next: NextFunction) => {
    const user = req.user; // 認証ミドルウェアで設定済み
    if (!user) {
      return res.status(401).json({ error: 'Authentication required' });
    }
 
    // ユーザーの権限を取得（キャッシュ付き）
    const userPermissions = await getCachedPermissions(user.id);
 
    // 全ての必要権限を持っているか確認
    const hasAll = requiredPermissions.every((p) => userPermissions.has(p));
    if (!hasAll) {
      return res.status(403).json({
        error: 'Insufficient permissions',
        required: requiredPermissions,
        hint: 'Contact your administrator to request access',
      });
    }
 
    next();
  };
}
 
// いずれかの権限を持っていれば OK
function requireAnyPermission(...requiredPermissions: string[]) {
  return async (req: Request, res: Response, next: NextFunction) => {
    const user = req.user;
    if (!user) {
      return res.status(401).json({ error: 'Authentication required' });
    }
 
    const userPermissions = await getCachedPermissions(user.id);
    const hasAny = requiredPermissions.some((p) => userPermissions.has(p));
 
    if (!hasAny) {
      return res.status(403).json({
        error: 'Insufficient permissions',
        required_any: requiredPermissions,
      });
    }
 
    next();
  };
}
 
// 使用例
app.get('/api/articles', requirePermission('articles:read'), getArticles);
app.post('/api/articles', requirePermission('articles:create'), createArticle);
app.put('/api/articles/:id', requirePermission('articles:update'), updateArticle);
app.delete('/api/articles/:id', requirePermission('articles:delete'), deleteArticle);
app.post('/api/articles/:id/publish', requirePermission('articles:publish'), publishArticle);
 
// 複数権限が必要な場合
app.delete('/api/users/:id',
  requirePermission('users:delete', 'users:read'),
  deleteUser
);
 
// いずれかの権限でアクセス可能
app.get('/api/reports',
  requireAnyPermission('reports:read', 'admin'),
  getReports
);

// Next.js Server Actions での権限チェック
import { auth } from '@/auth';
import { redirect } from 'next/navigation';
 
// 権限チェックユーティリティ
async function authorize(...requiredPermissions: string[]) {
  const session = await auth();
 
  if (!session) {
    redirect('/login');
  }
 
  const userPermissions = resolvePermissions(session.user.role);
  const hasAll = requiredPermissions.every((p) =>
    userPermissions.has(p as Permission)
  );
 
  if (!hasAll) {
    throw new Error(
      `Insufficient permissions. Required: ${requiredPermissions.join(', ')}`
    );
  }
 
  return session;
}
 
// Server Action での使用例
'use server';
 
async function createArticle(formData: FormData) {
  const session = await authorize('articles:create');
 
  const article = await prisma.article.create({
    data: {
      title: formData.get('title') as string,
      content: formData.get('content') as string,
      authorId: session.user.id,
    },
  });
 
  revalidatePath('/articles');
  return article;
}
 
async function deleteArticle(articleId: string) {
  const session = await authorize('articles:delete');
 
  await prisma.article.delete({
    where: { id: articleId },
  });
 
  revalidatePath('/articles');
}
 
async function inviteUser(email: string, role: string) {
  const session = await authorize('users:invite', 'users:create');
 
  // 招待するロールが自分のロールより高くないことを確認
  const inviterPermissions = resolvePermissions(session.user.role);
  const inviteePermissions = resolvePermissions(role);
 
  // 招待先のロールが自分にない権限を持っている場合はエラー
  for (const perm of inviteePermissions) {
    if (!inviterPermissions.has(perm)) {
      throw new Error('Cannot assign a role with higher permissions than your own');
    }
  }
 
  await sendInvitation(email, role);
}

// マルチテナント RBAC の実装
interface OrgMembership {
  userId: string;
  orgId: string;
  role: string;
  joinedAt: Date;
}
 
// 組織内の権限チェック
async function checkOrgPermission(
  userId: string,
  orgId: string,
  permission: string
): Promise<boolean> {
  const membership = await prisma.organizationMember.findUnique({
    where: {
      userId_orgId: { userId, orgId },
    },
  });
 
  if (!membership) return false;
 
  // ロールの権限を解決
  return hasPermission(membership.role, permission as Permission);
}
 
// 組織コンテキスト付きミドルウェア
function requireOrgPermission(...permissions: string[]) {
  return async (req: Request, res: Response, next: NextFunction) => {
    const user = req.user;
    if (!user) {
      return res.status(401).json({ error: 'Unauthorized' });
    }
 
    // URL から orgId を取得（/org/:orgId/...）
    const orgId = req.params.orgId;
    if (!orgId) {
      return res.status(400).json({ error: 'Organization ID required' });
    }
 
    const hasAll = await Promise.all(
      permissions.map((p) => checkOrgPermission(user.id, orgId, p))
    );
 
    if (hasAll.some((v) => !v)) {
      return res.status(403).json({
        error: 'Insufficient permissions in this organization',
      });
    }
 
    // 組織情報をリクエストに付与
    req.orgId = orgId;
    next();
  };
}
 
// Next.js Server Component での組織コンテキスト
async function OrgDashboard({ params }: { params: { orgId: string } }) {
  const session = await auth();
  if (!session) redirect('/login');
 
  const membership = await prisma.organizationMember.findUnique({
    where: {
      userId_orgId: {
        userId: session.user.id,
        orgId: params.orgId,
      },
    },
    include: { organization: true },
  });
 
  if (!membership) {
    notFound();
  }
 
  const permissions = resolvePermissions(membership.role);
 
  return (
    <div>
      <h1>{membership.organization.name}</h1>
      <p>Your role: {membership.role}</p>
 
      {permissions.has('articles:create' as Permission) && (
        <Link href={`/org/${params.orgId}/articles/new`}>New Article</Link>
      )}
 
      {permissions.has('users:read' as Permission) && (
        <Link href={`/org/${params.orgId}/members`}>Members</Link>
      )}
 
      {permissions.has('org:settings' as Permission) && (
        <Link href={`/org/${params.orgId}/settings`}>Settings</Link>
      )}
    </div>
  );
}

// 組織メンバー管理 API
class OrgMemberService {
  // メンバー招待
  async inviteMember(
    inviterId: string,
    orgId: string,
    email: string,
    role: string
  ) {
    // 招待者の権限チェック
    const inviterMembership = await prisma.organizationMember.findUnique({
      where: { userId_orgId: { userId: inviterId, orgId } },
    });
 
    if (!inviterMembership) {
      throw new Error('You are not a member of this organization');
    }
 
    if (!hasPermission(inviterMembership.role, 'users:invite' as Permission)) {
      throw new Error('You do not have permission to invite members');
    }
 
    // 招待先のロールが招待者以下であることを確認
    const inviterPerms = resolvePermissions(inviterMembership.role);
    const inviteePerms = resolvePermissions(role);
 
    for (const perm of inviteePerms) {
      if (!inviterPerms.has(perm)) {
        throw new Error('Cannot assign a role with higher permissions');
      }
    }
 
    // 招待を作成
    const invitation = await prisma.orgInvitation.create({
      data: {
        orgId,
        email,
        role,
        invitedBy: inviterId,
        expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
        token: crypto.randomBytes(32).toString('hex'),
      },
    });
 
    await sendInvitationEmail(email, invitation);
    return invitation;
  }
 
  // ロール変更
  async changeRole(
    adminId: string,
    orgId: string,
    targetUserId: string,
    newRole: string
  ) {
    // 管理者権限チェック
    const adminMembership = await prisma.organizationMember.findUnique({
      where: { userId_orgId: { userId: adminId, orgId } },
    });
 
    if (!hasPermission(adminMembership!.role, 'users:update' as Permission)) {
      throw new Error('Permission denied');
    }
 
    // 自分自身のロール変更は不可（別の管理者が必要）
    if (adminId === targetUserId) {
      throw new Error('Cannot change your own role');
    }
 
    await prisma.organizationMember.update({
      where: { userId_orgId: { userId: targetUserId, orgId } },
      data: { role: newRole },
    });
  }
}

// Redis キャッシュで権限チェックを高速化
import Redis from 'ioredis';
 
class PermissionCache {
  private redis: Redis;
  private ttl = 300; // 5分
 
  constructor(redisUrl: string) {
    this.redis = new Redis(redisUrl);
  }
 
  private key(userId: string, orgId?: string): string {
    return orgId ? `perms:${userId}:${orgId}` : `perms:${userId}`;
  }
 
  // キャッシュから権限を取得
  async get(userId: string, orgId?: string): Promise<Set<string> | null> {
    const cached = await this.redis.smembers(this.key(userId, orgId));
    return cached.length > 0 ? new Set(cached) : null;
  }
 
  // キャッシュに権限を保存
  async set(
    userId: string,
    permissions: Set<string>,
    orgId?: string
  ): Promise<void> {
    const key = this.key(userId, orgId);
    const pipeline = this.redis.pipeline();
    pipeline.del(key);
    if (permissions.size > 0) {
      pipeline.sadd(key, ...permissions);
    }
    pipeline.expire(key, this.ttl);
    await pipeline.exec();
  }
 
  // キャッシュを無効化（ロール変更時）
  async invalidate(userId: string, orgId?: string): Promise<void> {
    if (orgId) {
      await this.redis.del(this.key(userId, orgId));
    } else {
      // 全組織のキャッシュを削除
      const keys = await this.redis.keys(`perms:${userId}:*`);
      if (keys.length > 0) await this.redis.del(...keys);
      await this.redis.del(this.key(userId));
    }
  }
 
  // ロール変更時のイベントハンドラ
  async onRoleChanged(userId: string, orgId?: string): Promise<void> {
    await this.invalidate(userId, orgId);
  }
}
 
// キャッシュ付き権限取得
const permissionCache = new PermissionCache(process.env.REDIS_URL!);
 
async function getCachedPermissions(
  userId: string,
  orgId?: string
): Promise<Set<string>> {
  // キャッシュをチェック
  const cached = await permissionCache.get(userId, orgId);
  if (cached) return cached;
 
  // キャッシュミス → DB から取得
  const permissions = orgId
    ? await getOrgPermissions(userId, orgId)
    : await getUserPermissions(userId);
 
  // キャッシュに保存
  await permissionCache.set(userId, permissions, orgId);
 
  return permissions;
}

// LRU キャッシュ（小規模アプリ向け）
class InMemoryPermissionCache {
  private cache = new Map<string, {
    permissions: Set<string>;
    expiresAt: number;
  }>();
  private maxSize = 1000;
  private ttl = 5 * 60 * 1000; // 5分
 
  get(userId: string): Set<string> | null {
    const entry = this.cache.get(userId);
    if (!entry) return null;
    if (Date.now() > entry.expiresAt) {
      this.cache.delete(userId);
      return null;
    }
    return entry.permissions;
  }
 
  set(userId: string, permissions: Set<string>): void {
    // サイズ制限チェック
    if (this.cache.size >= this.maxSize) {
      // 最も古いエントリを削除
      const firstKey = this.cache.keys().next().value;
      if (firstKey) this.cache.delete(firstKey);
    }
 
    this.cache.set(userId, {
      permissions,
      expiresAt: Date.now() + this.ttl,
    });
  }
 
  invalidate(userId: string): void {
    this.cache.delete(userId);
  }
 
  clear(): void {
    this.cache.clear();
  }
}

// RBAC2: 制約の実装
 
// 相互排他ロール（同時に持てないロール）
const MUTUALLY_EXCLUSIVE_ROLES: [string, string][] = [
  ['approver', 'requester'],     // 承認者と申請者は兼任不可
  ['auditor', 'admin'],          // 監査役と管理者は兼任不可
];
 
// ロール割当時のバリデーション
async function assignRole(userId: string, newRole: string, orgId?: string) {
  // 現在のロールを取得
  const currentRoles = await getUserRoles(userId, orgId);
 
  // 相互排他チェック
  for (const [roleA, roleB] of MUTUALLY_EXCLUSIVE_ROLES) {
    if (newRole === roleA && currentRoles.includes(roleB)) {
      throw new Error(
        `Cannot assign "${newRole}": conflicts with existing role "${roleB}"`
      );
    }
    if (newRole === roleB && currentRoles.includes(roleA)) {
      throw new Error(
        `Cannot assign "${newRole}": conflicts with existing role "${roleA}"`
      );
    }
  }
 
  // 最大ロール数チェック
  const MAX_ROLES = 5;
  if (currentRoles.length >= MAX_ROLES) {
    throw new Error(`Maximum of ${MAX_ROLES} roles per user`);
  }
 
  // ロールを割当
  await prisma.userRole.create({
    data: { userId, roleId: newRole },
  });
}
 
// 職務分離（SoD）チェック
function checkSeparationOfDuties(
  userRoles: string[],
  operation: string
): boolean {
  // 例: 支払い承認は、支払い作成者とは別の人が行う必要がある
  const sodRules: Record<string, string[]> = {
    'payment:approve': ['payment:create'], // 承認者は作成者になれない
    'audit:sign': ['accounting:post'],      // 監査署名者は記帳者になれない
  };
 
  const conflictingOps = sodRules[operation];
  if (!conflictingOps) return true;
 
  const userPermissions = new Set<string>();
  userRoles.forEach((role) => {
    resolvePermissions(role).forEach((p) => userPermissions.add(p));
  });
 
  // 利益相反するオペレーションを持っていないかチェック
  return !conflictingOps.some((op) => userPermissions.has(op as Permission));
}

// NG: ロール名のハードコーディング
async function deleteArticle(userId: string, articleId: string) {
  const user = await prisma.user.findUnique({ where: { id: userId } });
 
  // ✗ ロール名をコードに直接書く
  if (user?.role !== 'admin' && user?.role !== 'super_admin') {
    throw new Error('Permission denied');
  }
 
  await prisma.article.delete({ where: { id: articleId } });
}
// 問題: ロールが変わるたびにコード修正が必要
 
// ✓ OK: 権限ベースでチェック
async function deleteArticleGood(userId: string, articleId: string) {
  const permissions = await getCachedPermissions(userId);
 
  // 権限名でチェック（ロール名に依存しない）
  if (!permissions.has('articles:delete')) {
    throw new Error('Permission denied');
  }
 
  await prisma.article.delete({ where: { id: articleId } });
}
// ロールを変更しても、権限の割当を変えるだけでコード修正不要

// NG: フロントエンドの表示制御のみで権限管理
// フロントエンド
function AdminPanel() {
  const { user } = useAuth();
  if (user.role !== 'admin') return null; // 非表示にするだけ
  return <AdminDashboard />;
}
 
// バックエンド API に権限チェックがない
app.delete('/api/users/:id', async (req, res) => {
  // ✗ 誰でもユーザーを削除できてしまう
  await prisma.user.delete({ where: { id: req.params.id } });
  res.json({ success: true });
});
 
// ✓ OK: バックエンドで必ず権限チェック
app.delete('/api/users/:id',
  requirePermission('users:delete'), // ミドルウェアでチェック
  async (req, res) => {
    await prisma.user.delete({ where: { id: req.params.id } });
    res.json({ success: true });
  }
);

// NG: デフォルト許可（明示的に拒否しないとアクセス可能）
function checkAccess(userRole: string, resource: string): boolean {
  const deniedResources: Record<string, string[]> = {
    viewer: ['admin-panel', 'billing'],
    editor: ['admin-panel'],
  };
 
  // ✗ リストにないリソースは許可（新しいリソース追加時に漏れる）
  return !(deniedResources[userRole]?.includes(resource));
}
 
// ✓ OK: デフォルト拒否（明示的に許可したもののみアクセス可能）
function checkAccessGood(userRole: string, permission: string): boolean {
  const permissions = resolvePermissions(userRole);
  // 明示的に許可されていなければ拒否
  return permissions.has(permission as Permission);
}

// テンプレート
function resolvePermissions(role: string): Set<string> {
  // TODO: 実装してください
  return new Set();
}
 
// テスト
console.assert(resolvePermissions('guest').size === 1);
console.assert(resolvePermissions('admin').has('articles:read')); // 継承
console.assert(!resolvePermissions('editor').has('users:read')); // admin のみ

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]