create-aiko 0.1.0

package/template/packages/api/src/dto/role.dto.ts

@@ -0,0 +1,16 @@
+import { IsNotEmpty, IsEmail, IsOptional, Length, Min, Max, IsInt } from '@ai-partner-x/aiko-boot-starter-validation';
+export class CreateRoleDto {
+  @IsNotEmpty({ message: '用户名不能为空' })
+  roleCode!: string;
+  roleName!: string;
+  description?: string;
+  status: number = 1;
+  menuIds?: number[];
+}
+
+export class UpdateRoleDto {
+  roleName?: string;
+  description?: string;
+  status?: number;
+  menuIds?: number[];
+}

package/template/packages/api/src/dto/user.dto.ts

@@ -0,0 +1,35 @@
+export class CreateUserDto {
+  username!: string;
+  password!: string;
+  realName?: string;
+  email?: string;
+  phone?: string;
+  status: number = 1;
+  roleIds?: number[];
+}
+
+export class UpdateUserDto {
+  realName?: string;
+  email?: string;
+  phone?: string;
+  status?: number;
+  roleIds?: number[];
+}
+
+export class UserPageDto {
+  pageNo: number = 1;
+  pageSize: number = 10;
+  username?: string;
+  status?: number;
+}
+
+export interface UserVo {
+  id: number;
+  username: string;
+  realName?: string;
+  email?: string;
+  phone?: string;
+  status: number;
+  roles: string[];
+  createdAt?: Date;
+}

package/template/packages/api/src/entity/menu.entity.ts

@@ -0,0 +1,34 @@
+import { Entity, TableId, TableField } from '@ai-partner-x/aiko-boot-starter-orm';
+
+@Entity({ tableName: 'sys_menu' })
+export class Menu {
+  @TableId({ type: 'AUTO' })
+  id!: number;
+
+  @TableField({ column: 'parent_id' })
+  parentId!: number; // 0 为顶级
+
+  @TableField({ column: 'menu_name' })
+  menuName!: string;
+
+  @TableField({ column: 'menu_type' })
+  menuType!: number; // 1目录 2菜单 3按钮
+
+  @TableField({ column: 'path' })
+  path?: string;
+
+  @TableField({ column: 'component' })
+  component?: string;
+
+  @TableField({ column: 'permission' })
+  permission?: string; // 权限标识，如 sys:user:list
+
+  @TableField({ column: 'icon' })
+  icon?: string;
+
+  @TableField({ column: 'sort_order' })
+  sortOrder!: number;
+
+  @TableField({ column: 'status' })
+  status!: number;
+}

package/template/packages/api/src/entity/role-menu.entity.ts

@@ -0,0 +1,13 @@
+import { Entity, TableId, TableField } from '@ai-partner-x/aiko-boot-starter-orm';
+
+@Entity({ tableName: 'sys_role_menu' })
+export class RoleMenu {
+  @TableId({ type: 'AUTO' })
+  id!: number;
+
+  @TableField({ column: 'role_id' })
+  roleId!: number;
+
+  @TableField({ column: 'menu_id' })
+  menuId!: number;
+}

package/template/packages/api/src/entity/role.entity.ts

@@ -0,0 +1,22 @@
+import { Entity, TableId, TableField } from '@ai-partner-x/aiko-boot-starter-orm';
+
+@Entity({ tableName: 'sys_role' })
+export class Role {
+  @TableId({ type: 'AUTO' })
+  id!: number;
+
+  @TableField({ column: 'role_code' })
+  roleCode!: string;
+
+  @TableField({ column: 'role_name' })
+  roleName!: string;
+
+  @TableField({ column: 'description' })
+  description?: string;
+
+  @TableField({ column: 'status' })
+  status!: number;
+
+  @TableField({ column: 'created_at' })
+  createdAt?: Date;
+}

package/template/packages/api/src/entity/user-role.entity.ts

@@ -0,0 +1,13 @@
+import { Entity, TableId, TableField } from '@ai-partner-x/aiko-boot-starter-orm';
+
+@Entity({ tableName: 'sys_user_role' })
+export class UserRole {
+  @TableId({ type: 'AUTO' })
+  id!: number;
+
+  @TableField({ column: 'user_id' })
+  userId!: number;
+
+  @TableField({ column: 'role_id' })
+  roleId!: number;
+}

package/template/packages/api/src/entity/user.entity.ts

@@ -0,0 +1,31 @@
+import { Entity, TableId, TableField } from '@ai-partner-x/aiko-boot-starter-orm';
+
+@Entity({ tableName: 'sys_user' })
+export class User {
+  @TableId({ type: 'AUTO' })
+  id!: number;
+
+  @TableField({ column: 'user_name' })
+  username!: string;
+
+  @TableField({ column: 'password_hash' })
+  passwordHash!: string;
+
+  @TableField({ column: 'real_name' })
+  realName?: string;
+
+  @TableField({ column: 'email' })
+  email!: string;
+
+  @TableField({ column: 'phone' })
+  phone?: string;
+
+  @TableField({ column: 'status' })
+  status!: number; // 1启用 0禁用
+
+  @TableField({ column: 'created_at' })
+  createdAt?: Date;
+
+  @TableField({ column: 'updated_at' })
+  updatedAt?: Date;
+}

package/template/packages/api/src/mapper/menu.mapper.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { Mapper, BaseMapper } from '@ai-partner-x/aiko-boot-starter-orm';
+import { Menu } from '../entity/menu.entity.js';
+
+@Mapper(Menu)
+export class MenuMapper extends BaseMapper<Menu> {}

package/template/packages/api/src/mapper/role-menu.mapper.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { Mapper, BaseMapper } from '@ai-partner-x/aiko-boot-starter-orm';
+import { RoleMenu } from '../entity/role-menu.entity.js';
+
+@Mapper(RoleMenu)
+export class RoleMenuMapper extends BaseMapper<RoleMenu> {}

package/template/packages/api/src/mapper/role.mapper.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { Mapper, BaseMapper } from '@ai-partner-x/aiko-boot-starter-orm';
+import { Role } from '../entity/role.entity.js';
+
+@Mapper(Role)
+export class RoleMapper extends BaseMapper<Role> {}

package/template/packages/api/src/mapper/user-role.mapper.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { Mapper, BaseMapper } from '@ai-partner-x/aiko-boot-starter-orm';
+import { UserRole } from '../entity/user-role.entity.js';
+
+@Mapper(UserRole)
+export class UserRoleMapper extends BaseMapper<UserRole> {}

package/template/packages/api/src/mapper/user.mapper.ts

@@ -0,0 +1,11 @@
+import 'reflect-metadata';
+import { Mapper, BaseMapper } from '@ai-partner-x/aiko-boot-starter-orm';
+import { User } from '../entity/user.entity.js';
+
+@Mapper(User)
+export class UserMapper extends BaseMapper<User> {
+  async selectByUsername(username: string): Promise<User | null> {
+    const user = await this.selectOne({ username });
+    return user;
+  }
+}

package/template/packages/api/src/scripts/init-db.ts

@@ -0,0 +1,185 @@
+/**
+ * 初始化数据库表结构和默认数据
+ * 运行: pnpm init-db
+ */
+import 'reflect-metadata';
+import { fileURLToPath } from 'url';
+import { pathToFileURL } from 'url';
+import { dirname, join } from 'path';
+import { mkdirSync, existsSync, readdirSync, statSync } from 'fs';
+import { createKyselyDatabase, getKyselyDatabase } from '@ai-partner-x/aiko-boot-starter-orm';
+import bcrypt from 'bcryptjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const dbPath = join(__dirname, '../../data/app.db');
+const dir = dirname(dbPath);
+if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+}
+
+await createKyselyDatabase({
+    type: 'sqlite',
+    filename: join(__dirname, '../../data/app.db'),
+});
+
+const db = getKyselyDatabase();
+
+// 建表
+await db.schema.createTable('sys_user').ifNotExists()
+    .addColumn('id', 'integer', (col: any) => col.primaryKey().autoIncrement())
+    .addColumn('user_name', 'varchar(50)', (col: any) => col.notNull().unique())
+    .addColumn('password_hash', 'varchar(255)', (col: any) => col.notNull())
+    .addColumn('real_name', 'varchar(50)')
+    .addColumn('email', 'varchar(100)')
+    .addColumn('phone', 'varchar(20)')
+    .addColumn('status', 'integer', (col: any) => col.notNull().defaultTo(1))
+    .addColumn('created_at', 'datetime')
+    .addColumn('updated_at', 'datetime')
+    .execute();
+
+await db.schema.createTable('sys_role').ifNotExists()
+    .addColumn('id', 'integer', (col: any) => col.primaryKey().autoIncrement())
+    .addColumn('role_code', 'varchar(50)', (col: any) => col.notNull().unique())
+    .addColumn('role_name', 'varchar(50)', (col: any) => col.notNull())
+    .addColumn('description', 'varchar(255)')
+    .addColumn('status', 'integer', (col: any) => col.notNull().defaultTo(1))
+    .addColumn('created_at', 'datetime')
+    .execute();
+
+await db.schema.createTable('sys_menu').ifNotExists()
+    .addColumn('id', 'integer', (col: any) => col.primaryKey().autoIncrement())
+    .addColumn('parent_id', 'integer', (col: any) => col.notNull().defaultTo(0))
+    .addColumn('menu_name', 'varchar(50)', (col: any) => col.notNull())
+    .addColumn('menu_type', 'integer', (col: any) => col.notNull())
+    .addColumn('path', 'varchar(255)')
+    .addColumn('component', 'varchar(255)')
+    .addColumn('permission', 'varchar(100)')
+    .addColumn('icon', 'varchar(100)')
+    .addColumn('sort_order', 'integer', (col: any) => col.notNull().defaultTo(0))
+    .addColumn('status', 'integer', (col: any) => col.notNull().defaultTo(1))
+    .execute();
+
+await db.schema.createTable('sys_user_role').ifNotExists()
+    .addColumn('id', 'integer', (col: any) => col.primaryKey().autoIncrement())
+    .addColumn('user_id', 'integer', (col: any) => col.notNull())
+    .addColumn('role_id', 'integer', (col: any) => col.notNull())
+    .execute();
+
+await db.schema.createTable('sys_role_menu').ifNotExists()
+    .addColumn('id', 'integer', (col: any) => col.primaryKey().autoIncrement())
+    .addColumn('role_id', 'integer', (col: any) => col.notNull())
+    .addColumn('menu_id', 'integer', (col: any) => col.notNull())
+    .execute();
+
+console.log('✅ 表结构创建完成');
+
+// 初始化超级管理员角色
+const roles = await db.selectFrom('sys_role').where('role_code', '=', 'SUPER_ADMIN').selectAll().execute();
+let adminRoleId: number;
+if (!roles.length) {
+    const result = await db.insertInto('sys_role')
+        .values({ role_code: 'SUPER_ADMIN', role_name: '超级管理员', description: '拥有全部权限', status: 1, created_at: new Date().toISOString() })
+        .executeTakeFirst();
+    adminRoleId = Number(result.insertId);
+    console.log('✅ 超级管理员角色创建完成');
+} else {
+    adminRoleId = roles[0].id as number;
+}
+
+// 初始化默认菜单
+const menuCount = await db.selectFrom('sys_menu').select(db.fn.count('id').as('cnt')).executeTakeFirst();
+const cntValue = menuCount && menuCount.cnt;
+if (Number(cntValue) === 0) {
+    // 系统管理目录
+    const sysDir = await db.insertInto('sys_menu')
+        .values({ parent_id: 0, menu_name: '系统管理', menu_type: 1, icon: 'Settings', sort_order: 100, status: 1 })
+        .executeTakeFirst();
+    const sysDirId = Number(sysDir.insertId);
+
+    const menus = [
+        { parent_id: sysDirId, menu_name: '用户管理', menu_type: 2, path: '/sys/user', permission: 'sys:user:list', sort_order: 1, status: 1 },
+        { parent_id: sysDirId, menu_name: '角色管理', menu_type: 2, path: '/sys/role', permission: 'sys:role:list', sort_order: 2, status: 1 },
+        { parent_id: sysDirId, menu_name: '菜单管理', menu_type: 2, path: '/sys/menu', permission: 'sys:menu:list', sort_order: 3, status: 1 },
+    ];
+    const insertedMenus = await db.insertInto('sys_menu').values(menus).executeTakeFirst();
+    console.log('✅ 默认菜单创建完成');
+
+    // 给超级管理员角色分配所有菜单
+    const allMenus = await db.selectFrom('sys_menu').select('id').execute();
+    for (const m of allMenus) {
+        await db.insertInto('sys_role_menu').values({ role_id: adminRoleId, menu_id: m.id as number }).execute();
+    }
+}
+
+// 初始化 admin 账号
+const users = await db.selectFrom('sys_user').where('user_name', '=', 'admin').selectAll().execute();
+if (!users.length) {
+    const hashed = await bcrypt.hash('admin123', 10);
+    const result = await db.insertInto('sys_user')
+        .values({ user_name: 'admin', password_hash: hashed, email: 'admin@example.com', real_name: '超级管理员', status: 1, created_at: new Date().toISOString(), updated_at: new Date().toISOString() })
+        .executeTakeFirst();
+    const adminUserId = Number(result.insertId);
+    await db.insertInto('sys_user_role').values({ user_id: adminUserId, role_id: adminRoleId }).execute();
+    console.log('✅ admin 账号创建完成 (密码: Admin@123)');
+} else {
+    console.log('ℹ️  admin 账号已存在，跳过');
+}
+
+await runGeneratedModuleInitializers(db);
+
+console.log('\n🎉 数据库初始化完成！');
+process.exit(0);
+
+async function runGeneratedModuleInitializers(dbInstance: any) {
+    const generatedDir = join(__dirname, 'generated');
+    if (!existsSync(generatedDir)) {
+        return;
+    }
+
+    const files = collectModuleFiles(generatedDir);
+    let loaded = 0;
+
+    for (const filePath of files) {
+        const fileUrl = pathToFileURL(filePath).href;
+        const mod = await import(fileUrl);
+        if (typeof mod.registerModuleTables === 'function') {
+            await mod.registerModuleTables(dbInstance);
+            loaded += 1;
+            console.log(`✅ 已加载业务模块初始化脚本: ${filePath}`);
+        }
+    }
+
+    if (loaded === 0) {
+        console.log('ℹ️  未发现业务模块初始化脚本，跳过');
+    }
+}
+
+function collectModuleFiles(baseDir: string): string[] {
+    const results: string[] = [];
+    const files = readdirSync(baseDir);
+
+    for (const file of files) {
+        const filePath = join(baseDir, file);
+        const stat = statSync(filePath);
+        if (stat.isDirectory()) {
+            results.push(...collectModuleFiles(filePath));
+            continue;
+        }
+
+        if (!isModuleFile(file)) {
+            continue;
+        }
+
+        results.push(filePath);
+    }
+
+    return results;
+}
+
+function isModuleFile(filename: string): boolean {
+    if (filename.endsWith('.d.ts') || filename.endsWith('.spec.ts') || filename.endsWith('.test.ts')) {
+        return false;
+    }
+
+    return filename.endsWith('.ts') || filename.endsWith('.js') || filename.endsWith('.mjs');
+}

package/template/packages/api/src/server.ts

@@ -0,0 +1,76 @@
+/**
+ * API Server - aiko-boot
+ */
+import { createApp } from '@ai-partner-x/aiko-boot';
+import { getExpressApp } from '@ai-partner-x/aiko-boot-starter-web';
+import { autoInit, getLogger } from '@ai-partner-x/aiko-boot-starter-log';
+import { RequestLogService } from './service/log.request.service';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import multer from 'multer';
+import express from 'express';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// 初始化日志系统（自动从app.config.ts加载配置）
+autoInit();
+
+// 获取服务器logger
+const logger = getLogger('server');
+
+logger.info('Starting API server...', {
+  nodeEnv: process.env.NODE_ENV || 'development',
+  timestamp: new Date().toISOString(),
+});
+
+const app = await createApp({ srcDir: __dirname });
+
+// 配置HTTP请求日志中间件
+const expressApp = getExpressApp();
+if (expressApp) {
+  // 添加请求日志中间件
+  expressApp.use(RequestLogService.requestLogMiddleware);
+  
+  // 配置 multer 文件上传中间件
+  const upload = multer({ storage: multer.memoryStorage() });
+  expressApp.post('/api/upload', upload.single('file'));
+  expressApp.post('/api/upload/multiple', upload.array('files', 10));
+
+  // 配置静态文件服务（本地存储时访问上传的文件）
+  const uploadsDir = join(__dirname, '..', 'uploads');
+  expressApp.use('/api/uploads', express.static(uploadsDir));
+  
+  logger.info('Express middleware configured', {
+    hasRequestLogging: true,
+    hasFileUpload: true,
+    hasStaticFiles: true,
+  });
+}
+
+await app.run();
+const port = app.config.get<number>('server.port', 3001);
+
+logger.info('API Server started successfully', {
+  port,
+  baseUrl: `http://localhost:${port}/api`,
+  env: process.env.NODE_ENV || 'development',
+  timestamp: new Date().toISOString(),
+});
+
+// 保留控制台输出以便兼容
+console.log(`\n📡 API: http://localhost:${port}/api\n`);
+
+// 全局错误处理
+process.on('uncaughtException', (error) => {
+  logger.error('Uncaught Exception', error, {
+    timestamp: new Date().toISOString(),
+    pid: process.pid,
+  });
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('Unhandled Rejection', reason instanceof Error ? reason : new Error(String(reason)), {
+    timestamp: new Date().toISOString(),
+    pid: process.pid,
+  });
+});

package/template/packages/api/src/service/auth.service.ts

@@ -0,0 +1,106 @@
+import 'reflect-metadata';
+import { Service, Autowired } from '@ai-partner-x/aiko-boot';
+import bcrypt from 'bcryptjs';
+import { UserMapper } from '../mapper/user.mapper.js';
+import { UserRoleMapper } from '../mapper/user-role.mapper.js';
+import { RoleMapper } from '../mapper/role.mapper.js';
+import { RoleMenuMapper } from '../mapper/role-menu.mapper.js';
+import { MenuMapper } from '../mapper/menu.mapper.js';
+
+import type { LoginDto, LoginResultDto } from '../dto/auth.dto.js';
+import { signAccessToken, signRefreshToken, verifyRefreshToken } from '../utils/jwt.util.js';
+
+@Service()
+export class AuthService {
+  @Autowired()
+  private userMapper!: UserMapper;
+
+  @Autowired()
+  private userRoleMapper!: UserRoleMapper;
+
+  @Autowired()
+  private roleMapper!: RoleMapper;
+
+  @Autowired()
+  private roleMenuMapper!: RoleMenuMapper;
+
+  @Autowired()
+  private menuMapper!: MenuMapper;
+
+  async login(dto: LoginDto): Promise<LoginResultDto> {
+    const user = await this.userMapper.selectByUsername(dto.username);
+    if (!user) {
+      throw new Error('用户名或密码错误');
+    }
+    if (user.status === 0) throw new Error('账户已被禁用');
+
+    const valid = await bcrypt.compare(dto.password, user.passwordHash);
+    if (!valid) throw new Error('用户名或密码错误');
+
+    const userRolesAndPerms = await this.getUserRolesAndPermissions(user.id);
+    const roles = userRolesAndPerms.roles;
+    const permissions = userRolesAndPerms.permissions;
+
+    const payload = { userId: user.id, username: user.username, roles, permissions };
+    return {
+      accessToken: signAccessToken(payload),
+      refreshToken: signRefreshToken({ userId: user.id }),
+      userInfo: { id: user.id, username: user.username, realName: user.realName, email: user.email, roles, permissions },
+    };
+  }
+
+  async refreshToken(refreshToken: string): Promise<{ accessToken: string }> {
+    const payload = verifyRefreshToken(refreshToken);
+    const user = await this.userMapper.selectById(payload.userId);
+    if (!user || user.status === 0) throw new Error('用户不存在或已禁用');
+
+    const userRolesAndPerms = await this.getUserRolesAndPermissions(user.id);
+    const roles = userRolesAndPerms.roles;
+    const permissions = userRolesAndPerms.permissions;
+    const accessToken = signAccessToken({ userId: user.id, username: user.username, roles, permissions });
+    return { accessToken };
+  }
+
+  async getUserInfo(userId: number): Promise<LoginResultDto['userInfo']> {
+    const user = await this.userMapper.selectById(userId);
+    if (!user) throw new Error('用户不存在');
+    const userRolesAndPerms = await this.getUserRolesAndPermissions(userId);
+    const roles = userRolesAndPerms.roles;
+    const permissions = userRolesAndPerms.permissions;
+    const safeUser: any = {};
+    for (const key in user) {
+      if (key !== 'password') {
+        safeUser[key] = user[key];
+      }
+    }
+    return { ...safeUser, roles, permissions };
+  }
+
+  private async getUserRolesAndPermissions(userId: number) {
+    const userRoles = await this.userRoleMapper.selectList({ userId });
+    if (!userRoles.length) return { roles: [] as string[], permissions: [] as string[] };
+
+    const roleIds: number[] = [];
+    for (let i = 0; i < userRoles.length; i++) {
+      roleIds.push(userRoles[i].roleId);
+    }
+    const roles: string[] = [];
+    const permissions: string[] = [];
+
+    for (let i = 0; i < roleIds.length; i++) {
+      const roleId = roleIds[i];
+      const role = await this.roleMapper.selectById(roleId);
+      if (role && role.status === 1) {
+        roles.push(role.roleCode);
+        const roleMenus = await this.roleMenuMapper.selectList({ roleId });
+        for (let j = 0; j < roleMenus.length; j++) {
+          const rm = roleMenus[j];
+          const menu = await this.menuMapper.selectById(rm.menuId);
+          if (menu && menu.permission) permissions.push(menu.permission);
+        }
+      }
+    }
+    return { roles: [...new Set(roles)], permissions: [...new Set(permissions)] };
+  }
+}
+

package/template/packages/api/src/service/cache.service.ts

@@ -0,0 +1,80 @@
+import 'reflect-metadata';
+import { Service } from '@ai-partner-x/aiko-boot';
+import type { CacheManager } from '@ai-partner-x/aiko-boot-starter-cache';
+import { getCacheManager, isCacheManagerInitialized } from '@ai-partner-x/aiko-boot-starter-cache';
+import type { CacheGetDto, CachePutDto, CacheEvictDto, CacheClearDto } from '../dto/cache.dto.js';
+
+@Service()
+export class CacheService {
+  private getCacheManagerInstance(): CacheManager {
+    if (!isCacheManagerInitialized()) {
+      throw new Error('Cache is not initialized. Enable cache in app.config.ts and ensure Redis is running.');
+    }
+    return getCacheManager();
+  }
+
+  /**
+   * 获取缓存值
+   * @param name 缓存命名空间
+   * @param key 缓存键
+   * @returns 缓存值（JSON 字符串），未命中返回 null
+   */
+  async get(dto: CacheGetDto): Promise<string | null> {
+    const cache = this.getCacheManagerInstance().getCache(dto.name);
+    const value = await cache.get(dto.key);
+    return value;
+  }
+
+  /**
+   * 设置缓存值
+   * @param name 缓存命名空间
+   * @param key 缓存键
+   * @param value 缓存值（任意类型，会自动序列化为 JSON 字符串存储）
+   * @param ttlSeconds 可选过期时间（秒）
+   */
+  async put(dto: CachePutDto): Promise<void> {
+    if (dto.value === undefined) {
+      throw new Error('Cache value is required and must be JSON-serializable.');
+    }
+
+    let value: string;
+    try {
+      value = JSON.stringify(dto.value);
+    } catch (err) {
+      throw new Error('Cache value is not JSON-serializable.');
+    }
+    const cache = this.getCacheManagerInstance().getCache(dto.name);
+    await cache.put(dto.key, value, dto.ttlSeconds);
+  }
+
+  /**
+   * 删除缓存条目
+   * @param name 缓存命名空间
+   * @param key 缓存键
+   * @param allEntries 是否清除所有条目
+   */
+  async evict(dto: CacheEvictDto): Promise<void> {
+    const cache = this.getCacheManagerInstance().getCache(dto.name);
+    if (dto.allEntries) {
+      await cache.clear();
+    } else {
+      await cache.evict(dto.key);
+    }
+  }
+
+  /**
+   * 清空缓存命名空间
+   * @param name 缓存命名空间
+   */
+  async clear(dto: CacheClearDto): Promise<void> {
+    const cache = this.getCacheManagerInstance().getCache(dto.name);
+    await cache.clear();
+  }
+
+  /**
+   * 检查缓存是否已初始化
+   */
+  isInitialized(): boolean {
+    return isCacheManagerInitialized();
+  }
+}