create-dp-koa 1.1.1 → 1.1.3

package/template/src/framework/interceptors/ServiceCallInterceptor.ts

@@ -1,348 +0,0 @@
-/**
- * Service调用拦截器插件
- * 用于监控和记录Service方法的完整调用周期
- */
-
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * Service调用周期阶段
- */
-export enum ServiceCallPhase {
-    BEFORE_CALL = 'BEFORE_CALL',
-    METHOD_EXECUTION = 'METHOD_EXECUTION', 
-    AFTER_CALL = 'AFTER_CALL',
-    ERROR_HANDLING = 'ERROR_HANDLING',
-    FINALLY = 'FINALLY'
-}
-
-/**
- * Service调用信息
- */
-export interface ServiceCallInfo {
-    serviceName: string;
-    methodName: string;
-    parameters: any[];
-    startTime: number;
-    endTime?: number;
-    duration?: number;
-    result?: any;
-    error?: Error;
-    phase: ServiceCallPhase;
-}
-
-/**
- * Service调用统计信息
- */
-export interface ServiceCallStats {
-    totalCalls: number;
-    successCalls: number;
-    errorCalls: number;
-    averageDuration: number;
-    maxDuration: number;
-    minDuration: number;
-    methodStats: Map<string, {
-        calls: number;
-        successes: number;
-        errors: number;
-        avgDuration: number;
-    }>;
-}
-
-/**
- * Service调用拦截器
- */
-export class ServiceCallInterceptor {
-    private static instance: ServiceCallInterceptor;
-    private callHistory: ServiceCallInfo[] = [];
-    private stats: ServiceCallStats = {
-        totalCalls: 0,
-        successCalls: 0,
-        errorCalls: 0,
-        averageDuration: 0,
-        maxDuration: 0,
-        minDuration: Infinity,
-        methodStats: new Map()
-    };
-    private maxHistorySize = 1000; // 最大历史记录数量
-
-    /**
-     * 获取单例实例
-     */
-    public static getInstance(): ServiceCallInterceptor {
-        if (!ServiceCallInterceptor.instance) {
-            ServiceCallInterceptor.instance = new ServiceCallInterceptor();
-        }
-        return ServiceCallInterceptor.instance;
-    }
-
-    /**
-     * 创建拦截器函数
-     * 符合dp-ioc2的Interceptor注解要求
-     */
-    public createInterceptor() {
-        return (params: Array<any>, instance: any, fn: Function, done: (err: any, param: any) => void) => {
-            const serviceName = instance.constructor.name;
-            const methodName = fn.name;
-            const startTime = Date.now();
-            
-            // 创建调用信息
-            const callInfo: ServiceCallInfo = {
-                serviceName,
-                methodName,
-                parameters: this.sanitizeParameters([...params]), // 存储脱敏后的参数
-                startTime,
-                phase: ServiceCallPhase.BEFORE_CALL
-            };
-
-            // 记录调用开始
-            this.logCallStart(callInfo);
-
-            // 更新统计信息
-            this.updateStats(callInfo, 'start');
-
-            // 执行原方法
-            try {
-                const result = fn.apply(instance, params);
-                
-                // 处理异步方法
-                if (result && typeof result.then === 'function') {
-                    result
-                        .then((res: any) => {
-                            callInfo.phase = ServiceCallPhase.AFTER_CALL;
-                            callInfo.endTime = Date.now();
-                            callInfo.duration = callInfo.endTime - callInfo.startTime;
-                            callInfo.result = this.sanitizeResult(res); // 存储脱敏后的结果
-                            
-                            this.logCallSuccess(callInfo);
-                            this.updateStats(callInfo, 'success');
-                            this.addToHistory(callInfo);
-                            
-                            done(null, res);
-                        })
-                        .catch((error: Error) => {
-                            callInfo.phase = ServiceCallPhase.ERROR_HANDLING;
-                            callInfo.endTime = Date.now();
-                            callInfo.duration = callInfo.endTime - callInfo.startTime;
-                            callInfo.error = error;
-                            
-                            this.logCallError(callInfo);
-                            this.updateStats(callInfo, 'error');
-                            this.addToHistory(callInfo);
-                            
-                            done(error, null);
-                        });
-                } else {
-                // 处理同步方法
-                callInfo.phase = ServiceCallPhase.AFTER_CALL;
-                callInfo.endTime = Date.now();
-                callInfo.duration = callInfo.endTime - callInfo.startTime;
-                callInfo.result = this.sanitizeResult(result); // 存储脱敏后的结果
-                
-                this.logCallSuccess(callInfo);
-                this.updateStats(callInfo, 'success');
-                this.addToHistory(callInfo);
-                
-                done(null, result);
-                }
-            } catch (error) {
-                callInfo.phase = ServiceCallPhase.ERROR_HANDLING;
-                callInfo.endTime = Date.now();
-                callInfo.duration = callInfo.endTime - callInfo.startTime;
-                callInfo.error = error as Error;
-                
-                this.logCallError(callInfo);
-                this.updateStats(callInfo, 'error');
-                this.addToHistory(callInfo);
-                
-                done(error, null);
-            }
-        };
-    }
-
-    /**
-     * 记录调用开始
-     */
-    private logCallStart(callInfo: ServiceCallInfo): void {
-        logger.info(`🚀 Service调用开始: ${callInfo.serviceName}.${callInfo.methodName}`, 
-            `参数: ${JSON.stringify(this.sanitizeParameters(callInfo.parameters))}, 时间: ${new Date(callInfo.startTime).toISOString()}`);
-    }
-
-    /**
-     * 记录调用成功
-     */
-    private logCallSuccess(callInfo: ServiceCallInfo): void {
-        logger.info(`✅ Service调用成功: ${callInfo.serviceName}.${callInfo.methodName}`, 
-            `耗时: ${callInfo.duration}ms, 结果: ${JSON.stringify(this.sanitizeResult(callInfo.result))}, 时间: ${new Date(callInfo.endTime!).toISOString()}`);
-    }
-
-    /**
-     * 记录调用错误
-     */
-    private logCallError(callInfo: ServiceCallInfo): void {
-        logger.error(`❌ Service调用失败: ${callInfo.serviceName}.${callInfo.methodName}`, 
-            callInfo.error, `耗时: ${callInfo.duration}ms, 时间: ${new Date(callInfo.endTime!).toISOString()}`);
-    }
-
-    /**
-     * 更新统计信息
-     */
-    private updateStats(callInfo: ServiceCallInfo, event: 'start' | 'success' | 'error'): void {
-        if (event === 'start') {
-            this.stats.totalCalls++;
-        } else if (event === 'success') {
-            this.stats.successCalls++;
-        } else if (event === 'error') {
-            this.stats.errorCalls++;
-        }
-
-        // 更新方法统计
-        const methodKey = `${callInfo.serviceName}.${callInfo.methodName}`;
-        if (!this.stats.methodStats.has(methodKey)) {
-            this.stats.methodStats.set(methodKey, {
-                calls: 0,
-                successes: 0,
-                errors: 0,
-                avgDuration: 0
-            });
-        }
-
-        const methodStat = this.stats.methodStats.get(methodKey)!;
-        if (event === 'start') {
-            methodStat.calls++;
-        } else if (event === 'success') {
-            methodStat.successes++;
-            methodStat.avgDuration = (methodStat.avgDuration * (methodStat.successes - 1) + callInfo.duration!) / methodStat.successes;
-        } else if (event === 'error') {
-            methodStat.errors++;
-        }
-
-        // 更新全局统计
-        if (callInfo.duration) {
-            this.stats.maxDuration = Math.max(this.stats.maxDuration, callInfo.duration);
-            this.stats.minDuration = Math.min(this.stats.minDuration, callInfo.duration);
-            this.stats.averageDuration = (this.stats.averageDuration * (this.stats.successCalls - 1) + callInfo.duration) / this.stats.successCalls;
-        }
-    }
-
-    /**
-     * 添加到历史记录
-     */
-    private addToHistory(callInfo: ServiceCallInfo): void {
-        this.callHistory.push(callInfo);
-        
-        // 限制历史记录大小
-        if (this.callHistory.length > this.maxHistorySize) {
-            this.callHistory.shift();
-        }
-    }
-
-    /**
-     * 清理敏感参数
-     */
-    private sanitizeParameters(params: any[]): any[] {
-        return params.map(param => {
-            if (typeof param === 'object' && param !== null) {
-                const sanitized = { ...param };
-                // 移除敏感字段
-                if ('password' in sanitized) sanitized.password = '***';
-                if ('token' in sanitized) sanitized.token = '***';
-                if ('secret' in sanitized) sanitized.secret = '***';
-                return sanitized;
-            }
-            return param;
-        });
-    }
-
-    /**
-     * 清理敏感结果
-     */
-    private sanitizeResult(result: any): any {
-        if (typeof result === 'object' && result !== null) {
-            const sanitized = { ...result };
-            if ('password' in sanitized) sanitized.password = '***';
-            if ('token' in sanitized) sanitized.token = '***';
-            if ('secret' in sanitized) sanitized.secret = '***';
-            return sanitized;
-        }
-        return result;
-    }
-
-    /**
-     * 获取调用历史
-     */
-    public getCallHistory(): ServiceCallInfo[] {
-        return [...this.callHistory];
-    }
-
-    /**
-     * 获取统计信息
-     */
-    public getStats(): ServiceCallStats {
-        return { ...this.stats };
-    }
-
-    /**
-     * 获取方法统计
-     */
-    public getMethodStats(methodKey: string): any {
-        return this.stats.methodStats.get(methodKey);
-    }
-
-    /**
-     * 清空历史记录
-     */
-    public clearHistory(): void {
-        this.callHistory = [];
-    }
-
-    /**
-     * 重置统计信息
-     */
-    public resetStats(): void {
-        this.stats = {
-            totalCalls: 0,
-            successCalls: 0,
-            errorCalls: 0,
-            averageDuration: 0,
-            maxDuration: 0,
-            minDuration: Infinity,
-            methodStats: new Map()
-        };
-    }
-
-    /**
-     * 生成调用报告
-     */
-    public generateReport(): string {
-        const stats = this.getStats();
-        const report = `
-📊 Service调用统计报告
-====================
-总调用次数: ${stats.totalCalls}
-成功调用: ${stats.successCalls}
-失败调用: ${stats.errorCalls}
-成功率: ${stats.totalCalls > 0 ? ((stats.successCalls / stats.totalCalls) * 100).toFixed(2) : 0}%
-平均耗时: ${stats.averageDuration.toFixed(2)}ms
-最大耗时: ${stats.maxDuration}ms
-最小耗时: ${stats.minDuration === Infinity ? 0 : stats.minDuration}ms
-
-📈 方法统计:
-${Array.from(stats.methodStats.entries()).map(([method, stat]) => 
-    `  ${method}: 调用${stat.calls}次, 成功${stat.successes}次, 失败${stat.errors}次, 平均${stat.avgDuration.toFixed(2)}ms`
-).join('\n')}
-        `;
-        
-        return report.trim();
-    }
-}
-
-/**
- * 创建拦截器实例
- */
-export const serviceCallInterceptor = ServiceCallInterceptor.getInstance();
-
-/**
- * 导出拦截器创建函数
- */
-export const createServiceCallInterceptor = () => serviceCallInterceptor.createInterceptor();

package/template/src/framework/interceptors/index.ts

@@ -1,19 +0,0 @@
-/**
- * 拦截器导出文件
- */
-
-export { 
-    ServiceCallInterceptor, 
-    serviceCallInterceptor, 
-    createServiceCallInterceptor,
-    ServiceCallPhase,
-    ServiceCallInfo,
-    ServiceCallStats
-} from './ServiceCallInterceptor';
-
-export {
-    AdvancedServiceCallInterceptor,
-    advancedServiceCallInterceptor,
-    createAdvancedServiceCallInterceptor,
-    InterceptorOptions
-} from './AdvancedServiceCallInterceptor';

package/template/src/framework/plugins/types.ts

@@ -1,15 +0,0 @@
-import type Koa from "koa";
-import type Router from "koa-router";
-
-export interface PluginDescriptor {
-  id: string;
-  displayName?: string;
-  enabled?: boolean | ((env: NodeJS.ProcessEnv) => boolean);
-
-  onBeforeBootstrap?(app: Koa): Promise<void> | void;
-  onAfterBootstrap?(app: Koa): Promise<void> | void;
-
-  registerRoutes?(router: Router): void;
-  entities?: Function[];
-}
-

package/template/src/framework/types/ServiceResult.ts

@@ -1,151 +0,0 @@
-/**
- * 通用服务结果代码枚举
- * 定义所有服务层可能返回的状态码
- */
-export enum CommonServiceResultCode {
-    SUCCESS = "SUCCESS",
-    FAIL = "FAIL",
-    ERROR = "ERROR",
-    NOT_FOUND = "NOT_FOUND",
-    VALIDATION_ERROR = "VALIDATION_ERROR",
-    UNAUTHORIZED = "UNAUTHORIZED",
-    FORBIDDEN = "FORBIDDEN",
-    CONFLICT = "CONFLICT",
-    TIMEOUT = "TIMEOUT",
-    RATE_LIMITED = "RATE_LIMITED",
-}
-
-/**
- * 通用服务结果类
- * 提供统一的服务层返回格式
- */
-export class CommonServiceResult<T> {
-    data: T | null;
-    message?: string;
-    code: CommonServiceResultCode;
-    
-    constructor(code: CommonServiceResultCode, data: T | null = null, message = "") {
-        this.code = code;
-        this.data = data;
-        this.message = message;
-    }
-
-    /**
-     * 判断是否成功
-     */
-    isSuccess(): boolean {
-        return this.code === CommonServiceResultCode.SUCCESS;
-    }
-
-    /**
-     * 判断是否失败
-     */
-    isFailure(): boolean {
-        return !this.isSuccess();
-    }
-
-    /**
-     * 获取错误信息
-     */
-    getErrorMessage(): string {
-        return this.message || this.getDefaultErrorMessage();
-    }
-
-    /**
-     * 获取默认错误信息
-     */
-    private getDefaultErrorMessage(): string {
-        switch (this.code) {
-            case CommonServiceResultCode.NOT_FOUND:
-                return "资源不存在";
-            case CommonServiceResultCode.VALIDATION_ERROR:
-                return "数据验证失败";
-            case CommonServiceResultCode.UNAUTHORIZED:
-                return "未授权访问";
-            case CommonServiceResultCode.FORBIDDEN:
-                return "禁止访问";
-            case CommonServiceResultCode.CONFLICT:
-                return "资源冲突";
-            case CommonServiceResultCode.TIMEOUT:
-                return "请求超时";
-            case CommonServiceResultCode.RATE_LIMITED:
-                return "请求频率过高";
-            case CommonServiceResultCode.ERROR:
-                return "服务器内部错误";
-            case CommonServiceResultCode.FAIL:
-                return "操作失败";
-            default:
-                return "未知错误";
-        }
-    }
-
-    /**
-     * 创建成功结果
-     */
-    static success<T>(data: T, message?: string): CommonServiceResult<T> {
-        return new CommonServiceResult(CommonServiceResultCode.SUCCESS, data, message);
-    }
-
-    /**
-     * 创建失败结果
-     */
-    static fail<T>(code: CommonServiceResultCode, message?: string, data: T | null = null): CommonServiceResult<T> {
-        return new CommonServiceResult(code, data, message);
-    }
-
-    /**
-     * 创建验证错误结果
-     */
-    static validationError<T>(message: string, data: T | null = null): CommonServiceResult<T> {
-        return new CommonServiceResult(CommonServiceResultCode.VALIDATION_ERROR, data, message);
-    }
-
-    /**
-     * 创建未找到结果
-     */
-    static notFound<T>(message?: string, data: T | null = null): CommonServiceResult<T> {
-        return new CommonServiceResult(CommonServiceResultCode.NOT_FOUND, data, message);
-    }
-
-    /**
-     * 创建未授权结果
-     */
-    static unauthorized<T>(message?: string, data: T | null = null): CommonServiceResult<T> {
-        return new CommonServiceResult(CommonServiceResultCode.UNAUTHORIZED, data, message);
-    }
-
-    /**
-     * 创建禁止访问结果
-     */
-    static forbidden<T>(message?: string, data: T | null = null): CommonServiceResult<T> {
-        return new CommonServiceResult(CommonServiceResultCode.FORBIDDEN, data, message);
-    }
-
-    /**
-     * 创建冲突结果
-     */
-    static conflict<T>(message?: string, data: T | null = null): CommonServiceResult<T> {
-        return new CommonServiceResult(CommonServiceResultCode.CONFLICT, data, message);
-    }
-
-    /**
-     * 创建超时结果
-     */
-    static timeout<T>(message?: string, data: T | null = null): CommonServiceResult<T> {
-        return new CommonServiceResult(CommonServiceResultCode.TIMEOUT, data, message);
-    }
-
-    /**
-     * 创建限流结果
-     */
-    static rateLimited<T>(message?: string, data: T | null = null): CommonServiceResult<T> {
-        return new CommonServiceResult(CommonServiceResultCode.RATE_LIMITED, data, message);
-    }
-
-    /**
-     * 创建服务器错误结果
-     */
-    static error<T>(message?: string, data: T | null = null): CommonServiceResult<T> {
-        return new CommonServiceResult(CommonServiceResultCode.ERROR, data, message);
-    }
-}

package/template/src/framework/types/index.ts

@@ -1,16 +0,0 @@
-/**
- * 框架通用类型导出
- * 提供统一的类型定义和导出
- */
-
-// 服务结果类型
-export { CommonServiceResultCode, CommonServiceResult } from './ServiceResult';
-
-// 缓存相关类型
-export { ICache } from '../utils/CacheManager';
-
-// DTO 验证类型
-export { ValidationResult } from '../utils/DtoValidator';
-
-// 数据库相关类型
-export { IBaseRepository } from '../../repository/interfaces/IBaseRepository';