create-aiko 0.1.0

package/template/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/template/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();

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

@@ -0,0 +1,94 @@
+import 'reflect-metadata';
+import { Service, Transactional } from '@ai-partner-x/aiko-boot';
+import { Autowired } from '@ai-partner-x/aiko-boot/di/server';
+import { MenuMapper } from '../mapper/menu.mapper.js';
+import { Menu } from '../entity/menu.entity.js';
+import type { CreateMenuDto, UpdateMenuDto, MenuTreeVo } from '../dto/menu.dto.js';
+
+@Service()
+export class MenuService {
+  @Autowired()
+  private menuMapper!: MenuMapper;
+
+  async getFullTree(): Promise<MenuTreeVo[]> {
+    const all = await this.menuMapper.selectList();
+    return this.buildTree(all, 0);
+  }
+
+  async getUserMenuTree(permissions: string[]): Promise<MenuTreeVo[]> {
+    const all = await this.menuMapper.selectList({ status: 1 });
+    const visible: any[] = [];
+    for (let i = 0; i < all.length; i++) {
+      const m = all[i];
+      if (m.menuType === 3) {
+        if (m.permission && permissions.includes(m.permission)) {
+          visible.push(m);
+        }
+      } else {
+        visible.push(m);
+      }
+    }
+    return this.buildTree(visible, 0);
+  }
+
+  async getById(id: number) {
+    const menu = await this.menuMapper.selectById(id);
+    if (!menu) throw new Error('菜单不存在');
+    return menu;
+  }
+
+  @Transactional()
+  async createMenu(dto: CreateMenuDto) {
+    const menu: Menu = {
+      id: 0,
+      parentId: dto.parentId !== undefined ? dto.parentId : 0,
+      menuName: dto.menuName,
+      menuType: dto.menuType,
+      path: dto.path,
+      component: dto.component,
+      permission: dto.permission,
+      icon: dto.icon,
+      sortOrder: dto.sortOrder !== undefined ? dto.sortOrder : 0,
+      status: dto.status !== undefined ? dto.status : 1,
+    };
+    const result:number = await this.menuMapper.insert(menu);
+    console.log("result", result);
+    if (result !== 1) {
+      throw new Error('创建菜单失败');
+    }
+    const menus = await this.menuMapper.selectList({ id: menu.id });
+    return menus[0] || null;
+  }
+
+  @Transactional()
+  async updateMenu(id: number, dto: UpdateMenuDto) {
+    const menu = await this.menuMapper.selectById(id);
+    if (!menu) throw new Error('菜单不存在');
+    Object.assign(menu, dto);
+    await this.menuMapper.updateById(menu);
+    return menu;
+  }
+
+  async deleteMenu(id: number): Promise<boolean> {
+    const children = await this.menuMapper.selectList({ parentId: id });
+    if (children.length) throw new Error('存在子菜单，无法删除');
+    return this.menuMapper.deleteById(id);
+  }
+
+  private buildTree(menus: any[], parentId: number): MenuTreeVo[] {
+    const result: MenuTreeVo[] = [];
+    for (let i = 0; i < menus.length; i++) {
+      const m = menus[i];
+      if (m.parentId === parentId) {
+        const children = this.buildTree(menus, m.id);
+        const item: MenuTreeVo = { ...m };
+        if (children.length > 0) {
+          item.children = children;
+        }
+        result.push(item);
+      }
+    }
+    result.sort((a, b) => a.sortOrder - b.sortOrder);
+    return result;
+  }
+}

package/template/packages/api/src/service/mq.consumer.service.ts

@@ -0,0 +1,26 @@
+import 'reflect-metadata';
+import { Service } from '@ai-partner-x/aiko-boot';
+import { MqListener, type MqListenerMeta } from '@ai-partner-x/aiko-boot-starter-mq';
+import type { UserEventDto } from '../dto/mq.dto.js';
+
+/**
+ * MQ 消费者服务 - 订阅 user 相关消息
+ * 复用 User 实体字段结构（id, username, email, createdAt, updatedAt）
+ */
+@Service()
+export class MqConsumerService {
+  static readonly MQ_LISTENERS: MqListenerMeta[] = [
+    { topic: 'user.created', tag: 'add', group: 'scaffold-user-group', method: 'onUserCreated' },
+    { topic: 'user.updated', tag: 'update', group: 'scaffold-user-group', method: 'onUserUpdated' },
+  ];
+
+  @MqListener({ topic: 'user.created', tag: 'add', group: 'scaffold-user-group' })
+  async onUserCreated(event: UserEventDto): Promise<void> {
+    console.log('[MqConsumer] user.created:', JSON.stringify(event));
+  }
+
+  @MqListener({ topic: 'user.updated', tag: 'update', group: 'scaffold-user-group' })
+  async onUserUpdated(event: UserEventDto): Promise<void> {
+    console.log('[MqConsumer] user.updated:', JSON.stringify(event));
+  }
+}

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

@@ -0,0 +1,88 @@
+import 'reflect-metadata';
+import { Service, Transactional } from '@ai-partner-x/aiko-boot';
+import { Autowired } from '@ai-partner-x/aiko-boot/di/server';
+import { RoleMapper } from '../mapper/role.mapper.js';
+import { RoleMenuMapper } from '../mapper/role-menu.mapper.js';
+import type { CreateRoleDto, UpdateRoleDto } from '../dto/role.dto.js';
+
+@Service()
+export class RoleService {
+  @Autowired()
+  private roleMapper!: RoleMapper;
+
+  @Autowired()
+  private roleMenuMapper!: RoleMenuMapper;
+
+  async listRoles() {
+    return this.roleMapper.selectList();
+  }
+
+  async getById(id: number) {
+    const role = await this.roleMapper.selectById(id);
+    if (!role) throw new Error('角色不存在');
+    const roleMenus = await this.roleMenuMapper.selectList({ roleId: id });
+    const menuIds: number[] = [];
+    for (let i = 0; i < roleMenus.length; i++) {
+      const rm = roleMenus[i];
+      menuIds.push(rm.menuId);
+    }
+    return { ...role, menuIds: menuIds };
+  }
+
+  @Transactional()
+  async createRole(dto: CreateRoleDto) {
+    console.log("dto", dto);
+    const exists = await this.roleMapper.selectList({ roleCode: dto.roleCode });
+    if (exists.length) throw new Error('角色编码已存在');
+    const status = dto.status !== undefined ? dto.status : 1;
+    await this.roleMapper.insert({
+      roleCode: dto.roleCode,
+      roleName: dto.roleName,
+      description: dto.description,
+      status: status,
+      createdAt: new Date().toISOString(),
+    });
+    const roles = await this.roleMapper.selectList({ roleCode: dto.roleCode });
+    const role = roles[0];
+    console.error("role", role);
+    if (!role) throw new Error('创建角色失败');
+    if (dto.menuIds !== undefined && dto.menuIds.length > 0) await this.assignMenus(role.id, dto.menuIds);
+    return role;
+  }
+
+  @Transactional()
+  async updateRole(id: number, dto: UpdateRoleDto) {
+    const role = await this.roleMapper.selectById(id);
+    if (!role) throw new Error('角色不存在');
+    if (dto.roleName !== undefined) role.roleName = dto.roleName;
+    if (dto.description !== undefined) role.description = dto.description;
+    if (dto.status !== undefined) role.status = dto.status;
+    await this.roleMapper.updateById(role);  
+    if (dto.menuIds !== undefined) await this.assignMenus(id, dto.menuIds);
+    return role;
+  }
+
+  async deleteRole(id: number): Promise<boolean> {
+    const role = await this.roleMapper.selectById(id);
+    if (!role) throw new Error('角色不存在');
+    await this.roleMenuMapper.delete({ roleId: id });
+    return this.roleMapper.deleteById(id);
+  }
+
+  async getRoleMenuIds(roleId: number): Promise<number[]> {
+    const roleMenus = await this.roleMenuMapper.selectList({ roleId });
+    const menuIds: number[] = [];
+    for (let i = 0; i < roleMenus.length; i++) {
+      const rm = roleMenus[i];
+      menuIds.push(rm.menuId);
+    }
+    return menuIds;
+  }
+
+  private async assignMenus(roleId: number, menuIds: number[]) {
+    await this.roleMenuMapper.delete({ roleId });
+    for (const menuId of menuIds) {
+      await this.roleMenuMapper.insert({ roleId, menuId });
+    }
+  }
+}

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

@@ -0,0 +1,170 @@
+import 'reflect-metadata';
+import { Injectable, Autowired } from '@ai-partner-x/aiko-boot/di/server';
+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 type { CreateUserDto, UpdateUserDto, UserPageDto, UserVo } from '../dto/user.dto.js';
+
+@Injectable()
+export class UserService {
+  @Autowired()
+  private userMapper!: UserMapper;
+
+  @Autowired()
+  private userRoleMapper!: UserRoleMapper;
+
+  @Autowired()
+  private roleMapper!: RoleMapper;
+
+  async pageUsers(params: UserPageDto) {
+    const allUsers = await this.userMapper.selectList();
+    let filtered = allUsers;
+    if (params.username) {
+      const username = params.username;
+      const temp: typeof allUsers = [];
+      for (let i = 0; i < filtered.length; i++) {
+        const u = filtered[i];
+        if (u.username.includes(username)) {
+          temp.push(u);
+        }
+      }
+      filtered = temp;
+    }
+    if (params.status !== undefined) {
+      const status = params.status;
+      const temp: typeof allUsers = [];
+      for (let i = 0; i < filtered.length; i++) {
+        const u = filtered[i];
+        if (u.status === status) {
+          temp.push(u);
+        }
+      }
+      filtered = temp;
+    }
+    const pageNo = params.pageNo || 1;
+    const pageSize = params.pageSize || 10;
+    const total = filtered.length;
+    const start = (pageNo - 1) * pageSize;
+    const end = start + pageSize;
+    const records = filtered.slice(start, end);
+    const usersWithRoles: UserVo[] = [];
+    for (let i = 0; i < records.length; i++) {
+      const u = records[i];
+      const vo = await this.toVo(this.parseEntityDates(u));
+      usersWithRoles.push(vo);
+    }
+    return { records: usersWithRoles, total, pageNo, pageSize, totalPages: Math.ceil(total / pageSize) };
+  }
+
+  async getById(id: number): Promise<UserVo> {
+    const user = await this.userMapper.selectById(id);
+    if (!user) throw new Error('用户不存在');
+    return this.toVo(this.parseEntityDates(user));
+  }
+
+
+
+  async createUser(dto: CreateUserDto): Promise<UserVo> {
+    const exists = await this.userMapper.selectByUsername(dto.username);
+    if (exists) throw new Error('用户名已存在');
+    const hashed = await bcrypt.hash(dto.password, 10);
+    const status = dto.status !== undefined ? dto.status : 1;
+    await this.userMapper.insert({
+      username: dto.username,
+      passwordHash: hashed,
+      realName: dto.realName,
+      email: dto.email,
+      phone: dto.phone,
+      status: status,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+    const user = await this.userMapper.selectByUsername(dto.username);
+    if (!user) throw new Error('创建用户失败');
+    if (dto.roleIds !== undefined && dto.roleIds.length > 0) await this.assignRoles(user.id, dto.roleIds);
+    return this.toVo(this.parseEntityDates(user));
+  }
+
+
+
+  async updateUser(id: number, dto: UpdateUserDto): Promise<UserVo> {
+    let user = await this.userMapper.selectById(id);
+    if (!user) throw new Error('用户不存在');
+    user = this.parseEntityDates(user);
+    if (dto.realName !== undefined) user.realName = dto.realName;
+    if (dto.email !== undefined) user.email = dto.email;
+    if (dto.phone !== undefined) user.phone = dto.phone;
+    if (dto.status !== undefined) user.status = dto.status;
+    user.updatedAt = new Date().toISOString();
+    await this.userMapper.updateById(this.formatEntityDates(user));
+    if (dto.roleIds !== undefined) await this.assignRoles(id, dto.roleIds);
+    return this.toVo(this.parseEntityDates(user));
+  }
+
+
+
+  async deleteUser(id: number): Promise<boolean> {
+    let user = await this.userMapper.selectById(id);
+    if (!user) throw new Error('用户不存在');
+    await this.userRoleMapper.delete({ userId: id });
+    return this.userMapper.deleteById(id);
+  }
+
+
+  async resetPassword(id: number, newPassword: string): Promise<void> {
+    let user = await this.userMapper.selectById(id);
+    if (!user) throw new Error('用户不存在');
+    user = this.parseEntityDates(user);
+    user.passwordHash = await bcrypt.hash(newPassword, 10);
+    user.updatedAt = new Date().toISOString();
+    await this.userMapper.updateById(this.formatEntityDates(user));
+  }
+
+
+  private async assignRoles(userId: number, roleIds: number[]) {
+    await this.userRoleMapper.delete({ userId });
+    for (const roleId of roleIds) {
+      await this.userRoleMapper.insert({ userId, roleId });
+    }
+  }
+
+  private parseEntityDates(entity: any): any {
+    const parsed = { ...entity };
+    if (parsed.createdAt && typeof parsed.createdAt === 'string') {
+      parsed.createdAt = new Date(parsed.createdAt);
+    }
+    if (parsed.updatedAt && typeof parsed.updatedAt === 'string') {
+      parsed.updatedAt = new Date(parsed.updatedAt);
+    }
+    return parsed;
+  }
+
+  private formatEntityDates(entity: any): any {
+    const formatted = { ...entity };
+    if (formatted.createdAt && formatted.createdAt instanceof Date) {
+      formatted.createdAt = formatted.createdAt.toISOString();
+    }
+    if (formatted.updatedAt && formatted.updatedAt instanceof Date) {
+      formatted.updatedAt = formatted.updatedAt.toISOString();
+    }
+    return formatted;
+  }
+
+  private async toVo(user: any): Promise<UserVo> {
+    const userRoles = await this.userRoleMapper.selectList({ userId: user.id });
+    const roles: string[] = [];
+    for (let i = 0; i < userRoles.length; i++) {
+      const ur = userRoles[i];
+      const role = await this.roleMapper.selectById(ur.roleId);
+      if (role) roles.push(role.roleCode);
+    }
+    const safe: any = {};
+    for (const key in user) {
+      if (key !== 'password') {
+        safe[key] = user[key];
+      }
+    }
+    return { ...safe, roles };
+  }
+}

package/template/packages/api/src/types/sqljs.d.ts

@@ -0,0 +1,18 @@
+declare module 'sql.js' {
+  export interface SqlJsInitConfig {
+    locateFile?: (file: string, prefix: string) => string;
+  }
+
+  export interface SqlJsDatabase {
+    run(sql: string, params?: unknown[]): void;
+    export(): Uint8Array;
+    close(): void;
+  }
+
+  export interface SqlJsStatic {
+    Database: new () => SqlJsDatabase;
+  }
+
+  export default function initSqlJs(config?: SqlJsInitConfig): Promise<SqlJsStatic>;
+}
+