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

package/templates/api-base/src/server.ts

@@ -0,0 +1,69 @@
+/**
+ * API Server - aiko-boot (base-api)
+ */
+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.js';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+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);
+
+  logger.info('Express middleware configured', {
+    hasRequestLogging: 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/templates/api-base/src/service/auth.service.ts

@@ -0,0 +1,144 @@
+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 as any)[key];
+      }
+    }
+    return { ...safeUser, roles, permissions };
+  }
+
+  async logout(token: string): Promise<{ ok: boolean }> {
+    // 当前实现中 JWT 为无状态，不做服务端记录，直接返回成功
+    return { ok: true };
+  }
+
+  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)],
+    };
+  }
+
+  async handleOAuthCallback(profile: any, tokens: any): Promise<any> {
+    // 这里可以根据第三方 profile 查找或创建本地用户，并返回登录结果。
+    // 为保持模板简洁，这里仅抛出未实现错误，由业务方按需扩展。
+    throw new Error('OAuth callback handler is not implemented in base-api.');
+  }
+}
+

package/templates/api-base/src/service/log.request.service.ts

@@ -0,0 +1,72 @@
+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();
+  }
+}
+

package/templates/api-base/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 } as any);
+    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 as any);
+    if (result !== 1) {
+      throw new Error('创建菜单失败');
+    }
+    const menus = await this.menuMapper.selectList({ id: (menu as any).id } as any);
+    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 as any, dto);
+    await this.menuMapper.updateById(menu as any);
+    return menu;
+  }
+
+  async deleteMenu(id: number): Promise<boolean> {
+    const children = await this.menuMapper.selectList({ parentId: id } as any);
+    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 as any) };
+        if (children.length > 0) {
+          (item as any).children = children;
+        }
+        result.push(item);
+      }
+    }
+    result.sort((a, b) => a.sortOrder - b.sortOrder);
+    return result;
+  }
+}
+

package/templates/api-base/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 } as any);
+    const menuIds: number[] = [];
+    for (let i = 0; i < roleMenus.length; i++) {
+      const rm = roleMenus[i];
+      menuIds.push(rm.menuId);
+    }
+    return { ...(role as any), menuIds: menuIds };
+  }
+
+  @Transactional()
+  async createRole(dto: CreateRoleDto) {
+    const exists = await this.roleMapper.selectList({ roleCode: dto.roleCode } as any);
+    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(),
+    } as any);
+    const roles = await this.roleMapper.selectList({ roleCode: dto.roleCode } as any);
+    const role = roles[0];
+    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 as any).roleName = dto.roleName;
+    if (dto.description !== undefined) (role as any).description = dto.description;
+    if (dto.status !== undefined) (role as any).status = dto.status;
+    await this.roleMapper.updateById(role as any);
+    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 } as any);
+    return this.roleMapper.deleteById(id);
+  }
+
+  async getRoleMenuIds(roleId: number): Promise<number[]> {
+    const roleMenus = await this.roleMenuMapper.selectList({ roleId } as any);
+    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 } as any);
+    for (const menuId of menuIds) {
+      await this.roleMenuMapper.insert({ roleId, menuId } as any);
+    }
+  }
+}
+

package/templates/api-base/src/service/user.service.ts

@@ -0,0 +1,175 @@
+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(),
+    } as any);
+    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 as any).realName = dto.realName;
+    if (dto.email !== undefined) (user as any).email = dto.email;
+    if (dto.phone !== undefined) (user as any).phone = dto.phone;
+    if (dto.status !== undefined) (user as any).status = dto.status;
+    (user as any).updatedAt = new Date().toISOString();
+    await this.userMapper.updateById(this.formatEntityDates(user) as any);
+    if (dto.roleIds !== undefined) await this.assignRoles(id, dto.roleIds);
+    return this.toVo(this.parseEntityDates(user));
+  }
+
+  async deleteUser(id: number): Promise<boolean> {
+    const user = await this.userMapper.selectById(id);
+    if (!user) throw new Error('用户不存在');
+    await this.userRoleMapper.delete({ userId: id } as any);
+    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 as any).passwordHash = await bcrypt.hash(newPassword, 10);
+    (user as any).updatedAt = new Date().toISOString();
+    await this.userMapper.updateById(this.formatEntityDates(user) as any);
+  }
+
+  private async assignRoles(userId: number, roleIds: number[]) {
+    await this.userRoleMapper.delete({ userId } as any);
+    for (const roleId of roleIds) {
+      await this.userRoleMapper.insert({ userId, roleId } as any);
+    }
+  }
+
+  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 } as any);
+    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 as any), roles } as UserVo;
+  }
+}
+

package/templates/api-base/src/utils/jwt.util.ts

@@ -0,0 +1,39 @@
+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/api-base/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "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"]
+}
+