create-dp-koa 1.1.2 → 1.1.4

package/template/src/annotations/processors/EnterprisePerformanceProcessor.ts

@@ -1,189 +0,0 @@
-/**
- * 企业级性能监控注解处理器
- * 提供详细的性能指标、监控和告警
- */
-
-import { Context } from 'koa';
-import { AnnotationProcessor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { logger } from '@src/framework/utils/logger';
-
-export interface PerformanceMetrics {
-    executionTime: number;
-    memoryUsage: {
-        rss: number;
-        heapUsed: number;
-        heapTotal: number;
-        external: number;
-    };
-    cpuUsage?: number;
-    requestSize?: number;
-    responseSize?: number;
-}
-
-export interface PerformanceConfig {
-    maxExecutionTime?: number;
-    maxMemoryUsage?: number;
-    enableMetrics?: boolean;
-    enableAlerts?: boolean;
-    alertThresholds?: {
-        executionTime?: number;
-        memoryUsage?: number;
-        errorRate?: number;
-    };
-}
-
-export class EnterprisePerformanceProcessor implements AnnotationProcessor {
-    readonly name = 'EnterprisePerformance';
-    readonly priority = 1; // 最高优先级
-
-    private metrics: Map<string, PerformanceMetrics[]> = new Map();
-    private alertThresholds: Map<string, PerformanceConfig> = new Map();
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: PerformanceConfig,
-        callParams: any[]
-    ): Promise<boolean> {
-        const startTime = process.hrtime.bigint();
-        const startMemory = process.memoryUsage();
-        const startCpu = process.cpuUsage();
-
-        // 存储性能监控数据
-        ctx.state.performanceMonitor = {
-            startTime,
-            startMemory,
-            startCpu,
-            methodName: `${controller.constructor.name}.${methodName}`,
-            config: annotationData || {},
-            requestSize: ctx.request.length || 0
-        };
-
-        // 记录开始时间
-        logger.info(`[${this.name}] 开始性能监控: ${controller.constructor.name}.${methodName}`);
-
-        return true;
-    }
-
-    async postProcess(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        response: any
-    ): Promise<void> {
-        const monitor = ctx.state.performanceMonitor;
-        if (!monitor) return;
-
-        const endTime = process.hrtime.bigint();
-        const endMemory = process.memoryUsage();
-        const endCpu = process.cpuUsage();
-
-        // 计算性能指标
-        const executionTime = Number(endTime - monitor.startTime) / 1000000; // 毫秒
-        const memoryDelta = {
-            rss: endMemory.rss - monitor.startMemory.rss,
-            heapUsed: endMemory.heapUsed - monitor.startMemory.heapUsed,
-            heapTotal: endMemory.heapTotal - monitor.startMemory.heapTotal,
-            external: endMemory.external - monitor.startMemory.external
-        };
-
-        const cpuDelta = {
-            user: endCpu.user - monitor.startCpu.user,
-            system: endCpu.system - monitor.startCpu.system
-        };
-
-        const metrics: PerformanceMetrics = {
-            executionTime,
-            memoryUsage: memoryDelta,
-            cpuUsage: (cpuDelta.user + cpuDelta.system) / 1000000, // 微秒转毫秒
-            requestSize: monitor.requestSize,
-            responseSize: JSON.stringify(response).length
-        };
-
-        // 存储指标
-        this.storeMetrics(monitor.methodName, metrics);
-
-        // 检查告警阈值
-        this.checkAlerts(monitor.methodName, metrics, monitor.config);
-
-        // 记录性能日志
-        logger.info(`[${this.name}] 性能指标: ${monitor.methodName}`, {
-            executionTime: `${executionTime.toFixed(2)}ms`,
-            memoryUsage: `${(memoryDelta.heapUsed / 1024 / 1024).toFixed(2)}MB`,
-            cpuUsage: `${metrics.cpuUsage?.toFixed(2)}ms`,
-            requestSize: `${metrics.requestSize}B`,
-            responseSize: `${metrics.responseSize}B`
-        });
-
-        // 清理上下文
-        delete ctx.state.performanceMonitor;
-    }
-
-    private storeMetrics(methodName: string, metrics: PerformanceMetrics): void {
-        if (!this.metrics.has(methodName)) {
-            this.metrics.set(methodName, []);
-        }
-
-        const methodMetrics = this.metrics.get(methodName)!;
-        methodMetrics.push(metrics);
-
-        // 只保留最近100条记录
-        if (methodMetrics.length > 100) {
-            methodMetrics.shift();
-        }
-    }
-
-    private checkAlerts(methodName: string, metrics: PerformanceMetrics, config: PerformanceConfig): void {
-        const thresholds = config.alertThresholds || {};
-        
-        // 执行时间告警
-        if (thresholds.executionTime && metrics.executionTime > thresholds.executionTime) {
-            logger.warn(`[${this.name}] ⚠️ 执行时间告警: ${methodName}`, {
-                executionTime: `${metrics.executionTime.toFixed(2)}ms`,
-                threshold: `${thresholds.executionTime}ms`
-            });
-        }
-
-        // 内存使用告警
-        if (thresholds.memoryUsage && Math.abs(metrics.memoryUsage.heapUsed) > thresholds.memoryUsage * 1024 * 1024) {
-            logger.warn(`[${this.name}] ⚠️ 内存使用告警: ${methodName}`, {
-                memoryUsage: `${(metrics.memoryUsage.heapUsed / 1024 / 1024).toFixed(2)}MB`,
-                threshold: `${thresholds.memoryUsage}MB`
-            });
-        }
-    }
-
-    /**
-     * 获取性能统计
-     */
-    getPerformanceStats(methodName?: string): any {
-        if (methodName) {
-            const metrics = this.metrics.get(methodName) || [];
-            return this.calculateStats(metrics);
-        }
-
-        const allStats: any = {};
-        this.metrics.forEach((metrics, name) => {
-            allStats[name] = this.calculateStats(metrics);
-        });
-        return allStats;
-    }
-
-    private calculateStats(metrics: PerformanceMetrics[]): any {
-        if (metrics.length === 0) return null;
-
-        const executionTimes = metrics.map(m => m.executionTime);
-        const memoryUsages = metrics.map(m => m.memoryUsage.heapUsed);
-
-        return {
-            count: metrics.length,
-            avgExecutionTime: executionTimes.reduce((a, b) => a + b, 0) / executionTimes.length,
-            maxExecutionTime: Math.max(...executionTimes),
-            minExecutionTime: Math.min(...executionTimes),
-            avgMemoryUsage: memoryUsages.reduce((a, b) => a + b, 0) / memoryUsages.length,
-            maxMemoryUsage: Math.max(...memoryUsages),
-            minMemoryUsage: Math.min(...memoryUsages)
-        };
-    }
-}

package/template/src/annotations/processors/PerformanceMonitorProcessor.ts

@@ -1,101 +0,0 @@
-import { Context } from 'koa';
-import { AnnotationProcessor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { isDebug } from '@src/framework/utils/function';
-
-/**
- * 性能监控注解处理器
- * 监控方法执行时间、内存使用等性能指标
- */
-export class PerformanceMonitorProcessor implements AnnotationProcessor {
-    readonly name = 'PerformanceMonitor';
-    readonly priority = 8; // 高优先级，在日志记录之前执行
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        const startTime = process.hrtime.bigint();
-        const startMemory = process.memoryUsage();
-        
-        // 只在调试模式下输出详细日志
-        if (isDebug()) {
-            console.log(`[${this.name}] 开始性能监控: ${controller.constructor.name}.${methodName}`);
-            console.log(`[${this.name}] 配置参数:`, annotationData);
-        }
-        
-        // 将性能监控数据存储到上下文中
-        ctx.state.performanceMonitor = {
-            startTime,
-            startMemory,
-            methodName: `${controller.constructor.name}.${methodName}`,
-            config: annotationData || {}
-        };
-        
-        return true;
-    }
-
-    /**
-     * 后置处理方法
-     * 在控制器方法执行完成后自动调用
-     */
-    async postProcess(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        response: any
-    ): Promise<void> {
-        this.logPerformance(ctx);
-    }
-
-    /**
-     * 记录性能监控结果
-     */
-    private logPerformance(ctx: Context): void {
-        const monitor = ctx.state.performanceMonitor;
-        if (!monitor) {
-            return;
-        }
-
-        const endTime = process.hrtime.bigint();
-        const endMemory = process.memoryUsage();
-        
-        // 计算执行时间（纳秒转毫秒）
-        const executionTime = Number(endTime - monitor.startTime) / 1000000;
-        
-        // 计算内存使用变化
-        const memoryDelta = {
-            rss: endMemory.rss - monitor.startMemory.rss,
-            heapUsed: endMemory.heapUsed - monitor.startMemory.heapUsed,
-            heapTotal: endMemory.heapTotal - monitor.startMemory.heapTotal,
-            external: endMemory.external - monitor.startMemory.external
-        };
-
-        // 只在调试模式下输出详细日志
-        if (isDebug()) {
-            console.log(`[PerformanceMonitor] 性能监控结果: ${monitor.methodName}`);
-            console.log(`[PerformanceMonitor] 执行时间: ${executionTime.toFixed(2)}ms`);
-            console.log(`[PerformanceMonitor] 内存使用变化:`, {
-                rss: `${(memoryDelta.rss / 1024 / 1024).toFixed(2)}MB`,
-                heapUsed: `${(memoryDelta.heapUsed / 1024 / 1024).toFixed(2)}MB`,
-                heapTotal: `${(memoryDelta.heapTotal / 1024 / 1024).toFixed(2)}MB`,
-                external: `${(memoryDelta.external / 1024 / 1024).toFixed(2)}MB`
-            });
-        }
-
-        // 性能警告（始终输出）
-        const config = monitor.config;
-        if (config.maxExecutionTime && executionTime > config.maxExecutionTime) {
-            console.warn(`[PerformanceMonitor] ⚠️ 执行时间超过阈值: ${executionTime.toFixed(2)}ms > ${config.maxExecutionTime}ms`);
-        }
-
-        if (config.maxMemoryUsage && Math.abs(memoryDelta.heapUsed) > config.maxMemoryUsage * 1024 * 1024) {
-            console.warn(`[PerformanceMonitor] ⚠️ 内存使用变化过大: ${(memoryDelta.heapUsed / 1024 / 1024).toFixed(2)}MB`);
-        }
-
-        // 清理上下文
-        delete ctx.state.performanceMonitor;
-    }
-}

package/template/src/annotations/processors/SecurityAuditProcessor.ts

@@ -1,345 +0,0 @@
-/**
- * 企业级安全审计注解处理器
- * 提供安全事件记录、审计日志和合规性检查
- */
-
-import { Context } from 'koa';
-import { AnnotationProcessor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { logger } from '@src/framework/utils/logger';
-
-export interface SecurityAuditConfig {
-    enableAudit?: boolean;
-    logLevel?: 'info' | 'warn' | 'error';
-    includeRequestData?: boolean;
-    includeResponseData?: boolean;
-    sensitiveFields?: string[];
-    complianceMode?: 'GDPR' | 'SOX' | 'HIPAA' | 'PCI-DSS';
-    retentionDays?: number;
-}
-
-export interface SecurityEvent {
-    timestamp: string;
-    userId?: string;
-    sessionId?: string;
-    ipAddress: string;
-    userAgent: string;
-    method: string;
-    url: string;
-    controller: string;
-    action: string;
-    requestData?: any;
-    responseData?: any;
-    securityLevel: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-    eventType: 'AUTHENTICATION' | 'AUTHORIZATION' | 'DATA_ACCESS' | 'DATA_MODIFICATION' | 'SYSTEM_ACCESS';
-    riskScore: number;
-    complianceFlags: string[];
-}
-
-export class SecurityAuditProcessor implements AnnotationProcessor {
-    readonly name = 'SecurityAudit';
-    readonly priority = 2; // 高优先级
-
-    private auditLog: SecurityEvent[] = [];
-    private complianceRules: Map<string, any> = new Map();
-
-    constructor() {
-        this.initializeComplianceRules();
-    }
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: SecurityAuditConfig,
-        callParams: any[]
-    ): Promise<boolean> {
-        if (!annotationData?.enableAudit) return true;
-
-        const config = annotationData;
-        
-        // 创建安全事件
-        const securityEvent: SecurityEvent = {
-            timestamp: new Date().toISOString(),
-            userId: ctx.state.user?.id,
-            sessionId: ctx.state.sessionId,
-            ipAddress: ctx.ip || ctx.request.ip,
-            userAgent: ctx.get('User-Agent') || '',
-            method: ctx.method,
-            url: ctx.url,
-            controller: controller.constructor.name,
-            action: methodName,
-            securityLevel: this.determineSecurityLevel(controller, methodName),
-            eventType: this.determineEventType(controller, methodName),
-            riskScore: this.calculateRiskScore(ctx, controller, methodName),
-            complianceFlags: this.checkCompliance(ctx, config)
-        };
-
-        // 添加请求数据（如果配置允许）
-        if (config.includeRequestData) {
-            securityEvent.requestData = this.sanitizeData(ctx.request.body, config.sensitiveFields);
-        }
-
-        // 存储事件
-        this.auditLog.push(securityEvent);
-
-        // 记录审计日志
-        this.logSecurityEvent(securityEvent, config.logLevel || 'info');
-
-        // 检查高风险操作
-        if (securityEvent.riskScore > 7) {
-            this.handleHighRiskEvent(securityEvent);
-        }
-
-        return true;
-    }
-
-    async postProcess(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        response: any
-    ): Promise<void> {
-        // 更新最后的安全事件
-        const lastEvent = this.auditLog[this.auditLog.length - 1];
-        if (lastEvent && lastEvent.controller === controller.constructor.name && lastEvent.action === methodName) {
-            lastEvent.responseData = this.sanitizeData(response, []);
-            
-            // 检查响应中的敏感数据泄露
-            this.checkDataLeakage(lastEvent);
-        }
-    }
-
-    private determineSecurityLevel(controller: any, methodName: string): SecurityEvent['securityLevel'] {
-        const controllerName = controller.constructor.name.toLowerCase();
-        const method = methodName.toLowerCase();
-
-        // 高风险操作
-        if (method.includes('delete') || method.includes('remove') || method.includes('destroy')) {
-            return 'CRITICAL';
-        }
-
-        // 中等风险操作
-        if (method.includes('update') || method.includes('modify') || method.includes('change')) {
-            return 'HIGH';
-        }
-
-        // 低风险操作
-        if (method.includes('get') || method.includes('list') || method.includes('find')) {
-            return 'LOW';
-        }
-
-        return 'MEDIUM';
-    }
-
-    private determineEventType(controller: any, methodName: string): SecurityEvent['eventType'] {
-        const controllerName = controller.constructor.name.toLowerCase();
-        const method = methodName.toLowerCase();
-
-        if (controllerName.includes('auth') || controllerName.includes('login')) {
-            return 'AUTHENTICATION';
-        }
-
-        if (method.includes('create') || method.includes('update') || method.includes('delete')) {
-            return 'DATA_MODIFICATION';
-        }
-
-        if (method.includes('get') || method.includes('list') || method.includes('find')) {
-            return 'DATA_ACCESS';
-        }
-
-        return 'SYSTEM_ACCESS';
-    }
-
-    private calculateRiskScore(ctx: Context, controller: any, methodName: string): number {
-        let score = 0;
-
-        // 基于HTTP方法
-        switch (ctx.method) {
-            case 'DELETE': score += 4; break;
-            case 'PUT': score += 3; break;
-            case 'POST': score += 2; break;
-            case 'GET': score += 1; break;
-        }
-
-        // 基于用户权限
-        if (!ctx.state.user) score += 3;
-        if (!ctx.state.user?.isAdmin) score += 1;
-
-        // 基于IP地址
-        if (this.isSuspiciousIP(ctx.ip)) score += 2;
-
-        // 基于时间
-        if (this.isOffHours()) score += 1;
-
-        return Math.min(score, 10);
-    }
-
-    private checkCompliance(ctx: Context, config: SecurityAuditConfig): string[] {
-        const flags: string[] = [];
-
-        if (config.complianceMode) {
-            const rules = this.complianceRules.get(config.complianceMode);
-            if (rules) {
-                // GDPR 检查
-                if (config.complianceMode === 'GDPR') {
-                    if (this.containsPersonalData(ctx.request.body)) {
-                        flags.push('GDPR_PERSONAL_DATA');
-                    }
-                }
-
-                // SOX 检查
-                if (config.complianceMode === 'SOX') {
-                    if (this.isFinancialData(ctx.request.body)) {
-                        flags.push('SOX_FINANCIAL_DATA');
-                    }
-                }
-            }
-        }
-
-        return flags;
-    }
-
-    private sanitizeData(data: any, sensitiveFields: string[] = []): any {
-        if (!data || typeof data !== 'object') return data;
-
-        const sanitized = { ...data };
-        
-        // 移除敏感字段
-        sensitiveFields.forEach(field => {
-            if (sanitized[field]) {
-                sanitized[field] = '[REDACTED]';
-            }
-        });
-
-        // 移除密码字段
-        if (sanitized.password) {
-            sanitized.password = '[REDACTED]';
-        }
-
-        return sanitized;
-    }
-
-    private logSecurityEvent(event: SecurityEvent, level: string): void {
-        const logData = {
-            securityEvent: event,
-            message: `Security audit: ${event.eventType} - ${event.controller}.${event.action}`,
-            riskScore: event.riskScore,
-            complianceFlags: event.complianceFlags
-        };
-
-        switch (level) {
-            case 'error':
-                logger.error(`[SecurityAudit] ${logData.message}`, undefined, logData);
-                break;
-            case 'warn':
-                logger.warn(`[SecurityAudit] ${logData.message}`, logData);
-                break;
-            default:
-                logger.info(`[SecurityAudit] ${logData.message}`, logData);
-        }
-    }
-
-    private handleHighRiskEvent(event: SecurityEvent): void {
-        logger.error(`[SecurityAudit] 高风险安全事件`, undefined, {
-            event,
-            alert: 'HIGH_RISK_SECURITY_EVENT',
-            timestamp: new Date().toISOString()
-        });
-
-        // 这里可以集成外部安全系统
-        // 例如：发送到 SIEM 系统、触发告警等
-    }
-
-    private checkDataLeakage(event: SecurityEvent): void {
-        if (event.responseData && typeof event.responseData === 'object') {
-            const responseStr = JSON.stringify(event.responseData);
-            
-            // 检查是否包含敏感信息
-            const sensitivePatterns = [
-                /password/i,
-                /ssn/i,
-                /credit.*card/i,
-                /social.*security/i
-            ];
-
-            sensitivePatterns.forEach(pattern => {
-                if (pattern.test(responseStr)) {
-                    logger.error(`[SecurityAudit] 潜在数据泄露`, undefined, {
-                        event,
-                        pattern: pattern.toString(),
-                        alert: 'POTENTIAL_DATA_LEAKAGE'
-                    });
-                }
-            });
-        }
-    }
-
-    private initializeComplianceRules(): void {
-        this.complianceRules.set('GDPR', {
-            personalDataFields: ['email', 'phone', 'address', 'name', 'ssn'],
-            retentionPeriod: 365
-        });
-
-        this.complianceRules.set('SOX', {
-            financialDataFields: ['amount', 'transaction', 'payment', 'invoice'],
-            auditTrail: true
-        });
-
-        this.complianceRules.set('HIPAA', {
-            healthDataFields: ['medical', 'health', 'diagnosis', 'treatment'],
-            encryptionRequired: true
-        });
-    }
-
-    private containsPersonalData(data: any): boolean {
-        const personalFields = ['email', 'phone', 'address', 'name', 'ssn'];
-        return personalFields.some(field => 
-            data && typeof data === 'object' && data[field]
-        );
-    }
-
-    private isFinancialData(data: any): boolean {
-        const financialFields = ['amount', 'transaction', 'payment', 'invoice'];
-        return financialFields.some(field => 
-            data && typeof data === 'object' && data[field]
-        );
-    }
-
-    private isSuspiciousIP(ip: string): boolean {
-        // 简单的可疑IP检查
-        const suspiciousRanges = ['192.168.', '10.', '172.'];
-        return suspiciousRanges.some(range => ip.startsWith(range));
-    }
-
-    private isOffHours(): boolean {
-        const hour = new Date().getHours();
-        return hour < 6 || hour > 22;
-    }
-
-    /**
-     * 获取审计日志
-     */
-    getAuditLog(filter?: Partial<SecurityEvent>): SecurityEvent[] {
-        if (!filter) return [...this.auditLog];
-
-        return this.auditLog.filter(event => {
-            return Object.keys(filter).every(key => 
-                event[key as keyof SecurityEvent] === filter[key as keyof SecurityEvent]
-            );
-        });
-    }
-
-    /**
-     * 清理过期日志
-     */
-    cleanupExpiredLogs(retentionDays: number = 90): void {
-        const cutoffDate = new Date();
-        cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
-
-        this.auditLog = this.auditLog.filter(event => 
-            new Date(event.timestamp) > cutoffDate
-        );
-
-        logger.info(`[SecurityAudit] 清理过期日志完成，保留 ${this.auditLog.length} 条记录`);
-    }
-}