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

package/templates/scaffold-default/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(MenuMapper)
+  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/templates/scaffold-default/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/templates/scaffold-default/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(RoleMapper)
+  private roleMapper!: RoleMapper;
+
+  @Autowired(RoleMenuMapper)
+  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/templates/scaffold-default/packages/api/src/service/user.service.ts

@@ -0,0 +1,195 @@
+import 'reflect-metadata';
+import { Injectable, Autowired } from '@ai-partner-x/aiko-boot/di/server';
+import { MethodPermission } from '@ai-partner-x/aiko-boot-starter-security';
+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(UserMapper)
+  private userMapper!: UserMapper;
+
+  @Autowired(UserRoleMapper)
+  private userRoleMapper!: UserRoleMapper;
+
+  @Autowired(RoleMapper)
+  private roleMapper!: RoleMapper;
+
+  @MethodPermission('user', 'page', {
+    description: '查询用户分页服务方法',
+    group: '用户服务',
+  })
+  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) };
+  }
+
+  @MethodPermission('user', 'read', {
+    description: '查询用户服务方法',
+    group: '用户服务',
+  })
+  async getById(id: number): Promise<UserVo> {
+    const user = await this.userMapper.selectById(id);
+    if (!user) throw new Error('用户不存在');
+    return this.toVo(this.parseEntityDates(user));
+  }
+
+
+
+  @MethodPermission('user', 'create', {
+    description: '创建用户服务方法',
+    group: '用户服务',
+  })
+  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));
+  }
+
+
+
+  @MethodPermission('user', 'update', {
+    description: '更新用户服务方法',
+    group: '用户服务',
+  })
+  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));
+  }
+
+
+
+  @MethodPermission('user', 'delete', {
+    description: '删除用户服务方法',
+    group: '用户服务',
+  })
+  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);
+  }
+
+
+  @MethodPermission('user', 'reset-password', {
+    description: '重置密码服务方法',
+    group: '用户服务',
+  })
+  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/templates/scaffold-default/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>;
+}
+

package/templates/scaffold-default/packages/api/src/utils/jwt.util.ts

@@ -0,0 +1,29 @@
+import jwt from 'jsonwebtoken';
+
+const JWT_SECRET = process.env.JWT_SECRET || 'ai-first-admin-secret-change-in-production';
+const JWT_REFRESH_SECRET = process.env.JWT_REFRESH_SECRET || 'ai-first-refresh-secret-change-in-production';
+const ACCESS_TOKEN_EXPIRES = '2h';
+const REFRESH_TOKEN_EXPIRES = '7d';
+
+export interface JwtPayload {
+  userId: number;
+  username: string;
+  roles: string[];
+  permissions: string[];
+}
+
+export function signAccessToken(payload: JwtPayload): string {
+  return jwt.sign(payload, JWT_SECRET, { expiresIn: ACCESS_TOKEN_EXPIRES });
+}
+
+export function signRefreshToken(payload: Pick<JwtPayload, 'userId'>): string {
+  return jwt.sign(payload, JWT_REFRESH_SECRET, { expiresIn: REFRESH_TOKEN_EXPIRES });
+}
+
+export function verifyAccessToken(token: string): JwtPayload {
+  return jwt.verify(token, JWT_SECRET) as JwtPayload;
+}
+
+export function verifyRefreshToken(token: string): Pick<JwtPayload, 'userId'> {
+  return jwt.verify(token, JWT_REFRESH_SECRET) as Pick<JwtPayload, 'userId'>;
+}

package/templates/scaffold-default/packages/api/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/scaffold-default/packages/api/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/server.ts'],
+  format: ['esm'],
+  dts: false,
+  clean: true,
+  external: [/^@ai-partner-x\//, 'reflect-metadata', 'express', 'cors'],
+  // Don't bundle to keep directory structure for Aiko Boot runtime discovery
+  bundle: false,
+  treeshake: false,
+  // Keep TypeScript source files for runtime discovery
+  splitting: false,
+});

package/templates/scaffold-default/packages/core/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@scaffold/core",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "lint": "eslint src"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "react": "^18.2.0",
+    "react-router": "^7.0.2",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0",
+    "react-router": "^7.0.0"
+  }
+}

package/templates/scaffold-default/packages/core/src/auth/auth-client-middleware.ts

@@ -0,0 +1,22 @@
+import { appAuth } from "./auth-service"
+
+export function createAuthClientMiddleware(callback?: () => void) {
+  if (!callback) {
+    callback = () => {
+      location.assign('/login')
+    }
+  }
+  return async function authClientMiddleware(
+    _args: {
+      request: Request
+      context: unknown
+    },
+    next: () => Promise<unknown>
+  ): Promise<void> {
+    const user = await appAuth.getIdentity()
+    if (!user) {
+      throw callback()
+    }
+    await next()
+  }
+}

package/templates/scaffold-default/packages/core/src/auth/auth-constants.ts

@@ -0,0 +1,6 @@
+/**
+ * Storage keys for auth state.
+ * - AUTH_ACCESS_TOKEN_KEY: used by backend-aware providers to store JWT access token only.
+ * - Default demo provider (default-auth-provider) uses a separate key "_kdid" for a serialized user blob; do not mix with token storage.
+ */
+export const AUTH_ACCESS_TOKEN_KEY = "_access_token"

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

@@ -0,0 +1,65 @@
+import { AuthProviderConfig, AuthUser, LoginParams } from "./types"
+
+export class AuthService {
+
+  private provider: AuthProviderConfig | null = null
+  private user: AuthUser | null = null
+
+  /** Centralized internal user state update to keep logic in one place. */
+  private setUser(user: AuthUser | null) {
+    this.user = user
+  }
+
+
+  async setup(provider: AuthProviderConfig) {
+    this.provider = provider
+    await this.getIdentity()
+    return this
+  }
+
+  private checkSetup() {
+    if (!this.provider) {
+      throw new Error('Auth Service: Provider is not setup')
+    }
+  }
+
+  async login(params: LoginParams) {
+    this.checkSetup()
+    const result = await this.provider!.login!(params)
+    if (result.success) {
+      this.setUser(result.user ?? null)
+    }
+    return result
+  }
+
+  async logout() {
+    this.checkSetup()
+    const result = await this.provider!.logout()
+    if (result.success) {
+      this.setUser(null)
+    }
+    return result
+  }
+
+  check() {
+    this.checkSetup()
+    return { isAuthenticated: !!this.user }
+  }
+
+  async getIdentity(): Promise<AuthUser | null> {
+    this.checkSetup()
+    if (this.user) {
+      return this.user
+    }
+    const result = await this.provider!.getIdentity()
+    if (result) {
+      this.setUser(result)
+    }
+    return result ?? null
+  }
+
+}
+
+const appAuth = new AuthService()
+
+export { appAuth }