@ai-partner-x/aiko-boot-cli 0.1.4

package/templates/scaffold-default/packages/api/src/scripts/update-admin-password.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+/**
+ * 更新数据库admin密码为admin123
+ */
+
+import bcrypt from 'bcryptjs';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+async function updateAdminPassword() {
+  try {
+    console.log('🔐 Starting admin password update process...');
+
+    // 生成admin123的密码哈希
+    const hashedPassword = await bcrypt.hash('admin123', 10);
+    console.log('🔐 Generated hash for admin123:', hashedPassword.substring(0, 20) + '...');
+
+    // 检查数据库文件
+    const dbPath = join(dirname(fileURLToPath(import.meta.url)), '../../data/app.db');
+    if (!fs.existsSync(dbPath)) {
+      throw new Error('Database file not found: ' + dbPath);
+    }
+    console.log('📁 Database file found:', dbPath);
+
+    // 重新初始化数据库
+    console.log('🔄 Re-initializing database with new password...');
+    const { execSync } = await import('child_process');
+
+    const result = execSync('node --import @swc-node/register/esm-register src/scripts/init-db.ts', {
+      cwd: process.cwd(),
+      stdio: 'inherit',
+      timeout: 30000
+    });
+
+    if (result.status === 0) {
+      console.log('✅ Database re-initialization completed successfully!');
+      console.log('');
+      console.log('🎉 Admin password has been updated to admin123!');
+      console.log('🎉 You can now login with: admin / admin123');
+      console.log('');
+      console.log('🔐 Please restart the server for changes to take effect.');
+    } else {
+      console.error('❌ Database initialization failed with code:', result.status);
+      console.error('Error output:', result.stderr);
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.error('❌ Error updating admin password:', error);
+    process.exit(1);
+  }
+}
+
+updateAdminPassword();

package/templates/scaffold-default/packages/api/src/scripts/user-roles.ts

@@ -0,0 +1,28 @@
+import 'reflect-metadata';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { createKyselyDatabase, getKyselyDatabase } from '@ai-partner-x/aiko-boot-starter-orm';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const dbPath = join(__dirname, '../../data/app.db');
+
+await createKyselyDatabase({
+    type: 'sqlite',
+    filename: dbPath,
+});
+
+const db = getKyselyDatabase();
+
+const users = await db.selectFrom('sys_user').selectAll().execute();
+console.log('用户:');
+console.log(JSON.stringify(users, null, 2));
+
+const roles = await db.selectFrom('sys_role').selectAll().execute();
+console.log('\n角色:');
+console.log(JSON.stringify(roles, null, 2));
+
+const userRoles = await db.selectFrom('sys_user_role').selectAll().execute();
+console.log('\n用户角色关联:');
+console.log(JSON.stringify(userRoles, null, 2));
+
+process.exit(0);

package/templates/scaffold-default/packages/api/src/server.ts

@@ -0,0 +1,38 @@
+import 'reflect-metadata';
+import express from 'express';
+import { createApp } from '@ai-partner-x/aiko-boot';
+import { autoInit, getLogger } from '@ai-partner-x/aiko-boot-starter-log';
+
+autoInit();
+const logger = getLogger('server');
+
+logger.info('Starting API server...');
+
+import { join } from 'path';
+
+const projectDir = process.cwd();
+const srcDir = join(projectDir, 'src'); // Framework scans for controller/service/mapper relative to srcDir
+const configPath = projectDir; // configPath should point to the directory with node_modules
+const context = await createApp({ srcDir, configPath, verbose: true });
+
+if (!context) {
+  logger.warn('ApplicationContext not available');
+} else {
+  logger.info('Security enabled: ' + context.config.get('security.enabled', true));
+}
+
+const expressApp = await import('@ai-partner-x/aiko-boot-starter-web').then(m => m.getExpressApp());
+
+if (!expressApp) {
+  logger.error('Express app not available');
+  process.exit(1);
+}
+
+expressApp.use(express.json());
+
+const port = context.config.get('server.port', 3001);
+
+expressApp.listen(port, () => {
+  logger.info('API Server started on port ' + port);
+  console.log('📡 API: http://localhost:' + port + '/api');
+});

package/templates/scaffold-default/packages/api/src/service/auth.service.ts

@@ -0,0 +1,165 @@
+import 'reflect-metadata';
+import { Service, Autowired } from '@ai-partner-x/aiko-boot';
+import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken'; // 只用于refresh token，access token使用安全组件
+import { JwtStrategy } from '@ai-partner-x/aiko-boot-starter-security';
+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 { User } from '@ai-partner-x/aiko-boot-starter-security';
+
+import type { LoginDto, LoginResultDto } from '../dto/auth.dto.js';
+
+@Service()
+export class AuthService {
+  @Autowired(UserMapper)
+  private userMapper!: UserMapper;
+
+  @Autowired(UserRoleMapper)
+  private userRoleMapper!: UserRoleMapper;
+
+  @Autowired(RoleMapper)
+  private roleMapper!: RoleMapper;
+
+  @Autowired(RoleMenuMapper)
+  private roleMenuMapper!: RoleMenuMapper;
+
+  @Autowired(MenuMapper)
+  private menuMapper!: MenuMapper;
+
+  @Autowired(JwtStrategy)
+  private jwtStrategy!: JwtStrategy;
+
+  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;
+
+    // 使用框架的User类型，包含roles和permissions字段
+    const frameworkUser = {
+      id: user.id,
+      username: user.username,
+      email: user.email,
+      roles: roles.map(function(r) { return { id: 0, name: r }; }), // 转换为框架格式
+      permissions: permissions, // 使用字符串数组格式
+    };
+
+    // 生成JWT token - 使用安全组件的JwtStrategy
+    const accessToken = await this.jwtStrategy.generateToken(frameworkUser as User);
+    const refreshToken = this.generateRefreshToken(user.id);
+
+    return {
+      accessToken: accessToken,
+      refreshToken: refreshToken,
+      userInfo: { id: user.id, username: user.username, realName: user.realName, email: user.email, roles, permissions },
+    };
+  }
+
+  async refreshToken(refreshToken: string): Promise<{ accessToken: string }> {
+    const payload = this.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 frameworkUser = {
+      id: user.id,
+      username: user.username,
+      email: user.email,
+      roles: roles.map(function(r) { return { id: 0, name: r }; }),
+      permissions: permissions,
+    };
+
+    const accessToken = await this.jwtStrategy.generateToken(frameworkUser as User);
+    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 };
+  }
+
+  async getCurrentUserByToken(accessToken: string): Promise<LoginResultDto['userInfo']> {
+    try {
+      // 使用安全组件的JwtStrategy验证token
+      const user = await this.jwtStrategy.validate(accessToken);
+      if (!user) {
+        throw new Error('Invalid token');
+      }
+      return this.getUserInfo(user.id);
+    } catch (error: any) {
+      if (error.name === 'TokenExpiredError') {
+        throw new Error('Token has expired');
+      } else if (error.name === 'JsonWebTokenError') {
+        throw new Error('Invalid token: ' + error.message);
+      } else if (error.name === 'NotBeforeError') {
+        throw new Error('Token not active yet');
+      }
+      throw error;
+    }
+  }
+
+  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)] };
+  }
+
+  // Refresh token 方法（使用独立的secret，与安全组件的JWT分离）
+  private generateRefreshToken(userId: number): string {
+    const secret = process.env.JWT_REFRESH_SECRET || 'ai-first-refresh-secret-change-in-production';
+    const expiresIn = '7d';
+
+    return jwt.sign({ userId }, secret, { expiresIn } as any);
+  }
+
+  private verifyRefreshToken(token: string): any {
+    const secret = process.env.JWT_REFRESH_SECRET || 'ai-first-refresh-secret-change-in-production';
+    return jwt.verify(token, secret);
+  }
+}
+

package/templates/scaffold-default/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();
+  }
+}

package/templates/scaffold-default/packages/api/src/service/log.request.service.ts

@@ -0,0 +1,158 @@
+import { Request, Response, NextFunction } from 'express';
+import { getLogger } from '@ai-partner-x/aiko-boot-starter-log';
+
+const logger = getLogger('http');
+
+/**
+ * HTTP请求日志服务
+ * 提供HTTP请求日志记录功能
+ */
+export class RequestLogService {
+  /**
+   * 完整的HTTP请求日志中间件
+   * 记录所有HTTP请求的详细信息
+   */
+  static requestLogMiddleware(req: Request, res: Response, next: NextFunction) {
+    const startTime = Date.now();
+    
+    // 获取请求信息
+    const requestInfo = {
+      method: req.method,
+      url: req.url,
+      path: req.path,
+      query: req.query,
+      ip: req.ip || req.connection.remoteAddress,
+      userAgent: req.get('user-agent') || 'unknown',
+      contentType: req.get('content-type'),
+      contentLength: req.get('content-length'),
+      referer: req.get('referer'),
+    };
+    
+    // 记录请求开始
+    logger.http('Request started', requestInfo);
+    
+    // 监听响应完成事件
+    res.on('finish', () => {
+      const duration = Date.now() - startTime;
+      
+      const responseInfo = {
+        ...requestInfo,
+        status: res.statusCode,
+        statusMessage: res.statusMessage,
+        duration: `${duration}ms`,
+        responseTime: duration,
+        timestamp: new Date().toISOString(),
+      };
+      
+      // 根据状态码选择日志级别
+      if (res.statusCode >= 500) {
+        logger.error('Request completed with server error', responseInfo);
+      } else if (res.statusCode >= 400) {
+        logger.warn('Request completed with client error', responseInfo);
+      } else {
+        logger.http('Request completed successfully', responseInfo);
+      }
+    });
+    
+    // 监听响应关闭事件（客户端提前断开连接）
+    res.on('close', () => {
+      if (!res.writableFinished) {
+        const duration = Date.now() - startTime;
+        logger.warn('Request closed by client before completion', {
+          ...requestInfo,
+          duration: `${duration}ms`,
+          timestamp: new Date().toISOString(),
+        });
+      }
+    });
+    
+    next();
+  }
+
+  /**
+   * 简化的请求日志中间件（仅记录基本信息）
+   */
+  static simpleRequestLogMiddleware(req: Request, res: Response, next: NextFunction) {
+    const startTime = Date.now();
+    
+    res.on('finish', () => {
+      const duration = Date.now() - startTime;
+      
+      logger.info(`${req.method} ${req.url} ${res.statusCode} ${duration}ms`, {
+        method: req.method,
+        url: req.url,
+        status: res.statusCode,
+        duration: `${duration}ms`,
+        ip: req.ip,
+      });
+    });
+    
+    next();
+  }
+
+  /**
+   * 错误请求日志中间件（专门记录错误请求）
+   */
+  static errorRequestLogMiddleware(req: Request, res: Response, next: NextFunction) {
+    const startTime = Date.now();
+    
+    res.on('finish', () => {
+      if (res.statusCode >= 400) {
+        const duration = Date.now() - startTime;
+        
+        logger.warn('Error request detected', {
+          method: req.method,
+          url: req.url,
+          status: res.statusCode,
+          duration: `${duration}ms`,
+          ip: req.ip,
+          userAgent: req.get('user-agent'),
+          timestamp: new Date().toISOString(),
+        });
+      }
+    });
+    
+    next();
+  }
+
+  /**
+   * 记录HTTP请求信息（直接调用，非中间件）
+   */
+  static logRequest(req: Request, res: Response, duration: number) {
+    const requestInfo = {
+      method: req.method,
+      url: req.url,
+      path: req.path,
+      query: req.query,
+      ip: req.ip || req.connection.remoteAddress,
+      userAgent: req.get('user-agent') || 'unknown',
+      status: res.statusCode,
+      statusMessage: res.statusMessage,
+      duration: `${duration}ms`,
+      responseTime: duration,
+      timestamp: new Date().toISOString(),
+    };
+
+    if (res.statusCode >= 500) {
+      logger.error('Request completed with server error', requestInfo);
+    } else if (res.statusCode >= 400) {
+      logger.warn('Request completed with client error', requestInfo);
+    } else {
+      logger.http('Request completed successfully', requestInfo);
+    }
+  }
+
+  /**
+   * 记录客户端提前断开连接
+   */
+  static logClientDisconnect(req: Request, duration: number) {
+    logger.warn('Request closed by client before completion', {
+      method: req.method,
+      url: req.url,
+      path: req.path,
+      ip: req.ip || req.connection.remoteAddress,
+      duration: `${duration}ms`,
+      timestamp: new Date().toISOString(),
+    });
+  }
+}

package/templates/scaffold-default/packages/api/src/service/log.service.ts

@@ -0,0 +1,123 @@
+import { getLogger, defaultLogger, ILogger } from '@ai-partner-x/aiko-boot-starter-log';
+
+/**
+ * 日志服务适配器
+ * 提供统一的日志接口，封装 aiko-boot-starter-log 的功能
+ */
+export class LogService {
+  private static instance: LogService;
+  private logger: ILogger;
+  
+  private constructor() {
+    // 使用命名logger，便于区分不同模块
+    this.logger = getLogger('scaffold-api');
+  }
+  
+  /**
+   * 获取日志服务单例
+   */
+  static getInstance(): LogService {
+    if (!LogService.instance) {
+      LogService.instance = new LogService();
+    }
+    return LogService.instance;
+  }
+  
+  /**
+   * 记录错误日志
+   * @param message 错误消息
+   * @param error 错误对象（可选）
+   * @param meta 附加元数据（可选）
+   */
+  error(message: string, error?: Error, meta?: Record<string, any>) {
+    this.logger.error(message, error, meta);
+  }
+  
+  /**
+   * 记录警告日志
+   * @param message 警告消息
+   * @param meta 附加元数据（可选）
+   */
+  warn(message: string, meta?: Record<string, any>) {
+    this.logger.warn(message, meta);
+  }
+  
+  /**
+   * 记录信息日志
+   * @param message 信息消息
+   * @param meta 附加元数据（可选）
+   */
+  info(message: string, meta?: Record<string, any>) {
+    this.logger.info(message, meta);
+  }
+  
+  /**
+   * 记录调试日志
+   * @param message 调试消息
+   * @param meta 附加元数据（可选）
+   */
+  debug(message: string, meta?: Record<string, any>) {
+    this.logger.debug(message, meta);
+  }
+  
+  /**
+   * 记录HTTP请求日志
+   * @param message HTTP消息
+   * @param meta 附加元数据（可选）
+   */
+  http(message: string, meta?: Record<string, any>) {
+    this.logger.http(message, meta);
+  }
+  
+  /**
+   * 记录详细日志
+   * @param message 详细消息
+   * @param meta 附加元数据（可选）
+   */
+  verbose(message: string, meta?: Record<string, any>) {
+    this.logger.verbose(message, meta);
+  }
+  
+  /**
+   * 记录最详细日志
+   * @param message 最详细消息
+   * @param meta 附加元数据（可选）
+   */
+  silly(message: string, meta?: Record<string, any>) {
+    this.logger.silly(message, meta);
+  }
+  
+  /**
+   * 检查是否启用指定级别的日志
+   * @param level 日志级别
+   */
+  isLevelEnabled(level: string): boolean {
+    return this.logger.isLevelEnabled(level);
+  }
+  
+  /**
+   * 获取原始logger实例
+   */
+  getLogger(): ILogger {
+    return this.logger;
+  }
+  
+  /**
+   * 创建子logger（用于模块划分）
+   * @param name 子logger名称
+   */
+  createChildLogger(name: string): ILogger {
+    return this.logger.child(name);
+  }
+  
+  /**
+   * 添加上下文信息
+   * @param context 上下文对象
+   */
+  withContext(context: Record<string, any>): ILogger {
+    return this.logger.withContext(context);
+  }
+}
+
+// 导出单例实例
+export const logService = LogService.getInstance();