create-dp-koa 1.0.0

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

@@ -0,0 +1,189 @@
+/**
+ * 企业级性能监控注解处理器
+ * 提供详细的性能指标、监控和告警
+ */
+
+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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,345 @@
+/**
+ * 企业级安全审计注解处理器
+ * 提供安全事件记录、审计日志和合规性检查
+ */
+
+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} 条记录`);
+    }
+}