create-dp-koa 1.0.0

package/template/src/framework/utils/metrics.ts

@@ -0,0 +1,182 @@
+import { logger } from '@src/framework/utils/logger';
+
+/**
+ * Prometheus指标收集器
+ */
+export class MetricsCollector {
+    private static instance: MetricsCollector;
+    private metrics: Map<string, any> = new Map();
+
+    private constructor() {
+        this.initializeMetrics();
+    }
+
+    static getInstance(): MetricsCollector {
+        if (!MetricsCollector.instance) {
+            MetricsCollector.instance = new MetricsCollector();
+        }
+        return MetricsCollector.instance;
+    }
+
+    /**
+     * 初始化指标
+     */
+    private initializeMetrics(): void {
+        // HTTP请求指标
+        this.metrics.set('http_requests_total', {
+            type: 'counter',
+            help: 'Total number of HTTP requests',
+            labels: ['method', 'route', 'status_code']
+        });
+
+        // HTTP请求持续时间
+        this.metrics.set('http_request_duration_seconds', {
+            type: 'histogram',
+            help: 'HTTP request duration in seconds',
+            labels: ['method', 'route'],
+            buckets: [0.1, 0.5, 1, 2, 5, 10]
+        });
+
+        // 活跃连接数
+        this.metrics.set('http_active_connections', {
+            type: 'gauge',
+            help: 'Number of active HTTP connections'
+        });
+
+        // 数据库连接数
+        this.metrics.set('database_connections_active', {
+            type: 'gauge',
+            help: 'Number of active database connections'
+        });
+
+        // 缓存命中率
+        this.metrics.set('cache_hits_total', {
+            type: 'counter',
+            help: 'Total number of cache hits',
+            labels: ['cache_name']
+        });
+
+        this.metrics.set('cache_misses_total', {
+            type: 'counter',
+            help: 'Total number of cache misses',
+            labels: ['cache_name']
+        });
+
+        // 错误计数
+        this.metrics.set('errors_total', {
+            type: 'counter',
+            help: 'Total number of errors',
+            labels: ['error_type', 'severity']
+        });
+
+        // 内存使用
+        this.metrics.set('memory_usage_bytes', {
+            type: 'gauge',
+            help: 'Memory usage in bytes',
+            labels: ['type']
+        });
+
+        // CPU使用率
+        this.metrics.set('cpu_usage_percent', {
+            type: 'gauge',
+            help: 'CPU usage percentage'
+        });
+    }
+
+    /**
+     * 记录HTTP请求
+     */
+    recordHttpRequest(method: string, route: string, statusCode: number, duration: number): void {
+        // 这里可以集成实际的Prometheus客户端
+        logger.debug('HTTP请求指标', {
+            method,
+            route,
+            statusCode,
+            duration
+        });
+    }
+
+    /**
+     * 记录错误
+     */
+    recordError(errorType: string, severity: string): void {
+        logger.debug('错误指标', {
+            errorType,
+            severity
+        });
+    }
+
+    /**
+     * 记录缓存操作
+     */
+    recordCacheOperation(cacheName: string, hit: boolean): void {
+        logger.debug('缓存指标', {
+            cacheName,
+            hit
+        });
+    }
+
+    /**
+     * 记录数据库连接
+     */
+    recordDatabaseConnection(active: number): void {
+        logger.debug('数据库连接指标', {
+            active
+        });
+    }
+
+    /**
+     * 获取系统指标
+     */
+    getSystemMetrics(): any {
+        const memUsage = process.memoryUsage();
+        const cpuUsage = process.cpuUsage();
+
+        return {
+            memory: {
+                rss: memUsage.rss,
+                heapTotal: memUsage.heapTotal,
+                heapUsed: memUsage.heapUsed,
+                external: memUsage.external
+            },
+            cpu: {
+                user: cpuUsage.user,
+                system: cpuUsage.system
+            },
+            uptime: process.uptime(),
+            pid: process.pid
+        };
+    }
+
+    /**
+     * 生成Prometheus格式的指标
+     */
+    generatePrometheusMetrics(): string {
+        const metrics: string[] = [];
+        const systemMetrics = this.getSystemMetrics();
+
+        // 内存指标
+        metrics.push(`# HELP memory_usage_bytes Memory usage in bytes`);
+        metrics.push(`# TYPE memory_usage_bytes gauge`);
+        metrics.push(`memory_usage_bytes{type="rss"} ${systemMetrics.memory.rss}`);
+        metrics.push(`memory_usage_bytes{type="heap_total"} ${systemMetrics.memory.heapTotal}`);
+        metrics.push(`memory_usage_bytes{type="heap_used"} ${systemMetrics.memory.heapUsed}`);
+        metrics.push(`memory_usage_bytes{type="external"} ${systemMetrics.memory.external}`);
+
+        // CPU指标
+        metrics.push(`# HELP cpu_usage_seconds CPU usage in seconds`);
+        metrics.push(`# TYPE cpu_usage_seconds gauge`);
+        metrics.push(`cpu_usage_seconds{type="user"} ${systemMetrics.cpu.user / 1000000}`);
+        metrics.push(`cpu_usage_seconds{type="system"} ${systemMetrics.cpu.system / 1000000}`);
+
+        // 进程指标
+        metrics.push(`# HELP process_uptime_seconds Process uptime in seconds`);
+        metrics.push(`# TYPE process_uptime_seconds gauge`);
+        metrics.push(`process_uptime_seconds ${systemMetrics.uptime}`);
+
+        return metrics.join('\n');
+    }
+}
+
+// 导出单例实例
+export const metricsCollector = MetricsCollector.getInstance();

package/template/src/framework/utils/router.ts

@@ -0,0 +1,417 @@
+import koaRouter from 'koa-router'
+import path from "path"
+import { IParamTypeEnum } from "@src/framework/decorator/controller"
+import { getRandoNumer, isPromise } from "@src/framework/utils/function"
+const _router = new koaRouter()
+import { Provider } from "dp-ioc2"
+import { validate } from "class-validator"
+import { Context } from "koa"
+import { logger } from '@src/framework/utils/logger'
+import { createCache, CacheType } from "@src/framework/utils/cache";
+
+// 导入新的路由系统
+import { callControllerWithProcessors } from '@src/framework/utils/NewRouter';
+
+// 配置开关：是否使用新的注解处理器系统
+// 动态检查环境变量，而不是在模块加载时固定
+function isNewAnnotationSystemEnabled(): boolean {
+    return process.env.USE_NEW_ANNOTATION_SYSTEM === '1';
+}
+
+// 使用统一的缓存管理创建控制器结果缓存
+const controllerResultCacheStore = createCache('controller-result', CacheType.CONTROLLER, {
+   stdTTL: 20, // 20秒过期
+   maxKeys: 2000 // 控制器缓存可以更多
+});
+
+const responseValidate = async function (controller: any, methods: string, res: any) {
+   if (controller.$_ResponseValidateIf && controller.$_ResponseValidateIf.get(methods)) {
+      const { fn, clas } = controller.$_ResponseValidateIf.get(methods);
+      let _callResult = fn(res);
+      if (isPromise(_callResult)) {
+         _callResult = await _callResult;
+      }
+      if (_callResult && (_callResult instanceof Object)) {
+         const _dto = new clas;
+         let dataObject = _callResult;
+         // for (let i in dataObject) {
+         //    _dto[i] = dataObject[i]
+         // }
+         Object.assign(_dto, dataObject);
+         return await validate(_dto, {
+            skipMissingProperties: false,
+            forbidNonWhitelisted: true,
+            whitelist: true,
+         });
+         // return await validate(_dto);
+      }
+   } else if (controller.$_ResponseValidator && controller.$_ResponseValidator.get(methods)) {
+      const { clas, objectKey } = controller.$_ResponseValidator.get(methods);
+      if (res instanceof Object) {
+         const _dto = new clas;
+         let dataObject = res;
+         if (objectKey && res[objectKey] && (res[objectKey] instanceof Object)) {
+            dataObject = res[objectKey];
+         }
+         // 严格验证所有字段
+         Object.assign(_dto, dataObject);
+         return await validate(_dto, {
+            skipMissingProperties: false,
+            forbidNonWhitelisted: true,
+            whitelist: true,
+         });
+      }
+   }
+   return []
+}
+
+
+async function callController(ctx: Context, controller: any, methods: string) {
+   if (isNewAnnotationSystemEnabled()) {
+      // 使用新的注解处理器系统
+      return await callControllerWithProcessors(ctx, controller, methods);
+   } else {
+      // 使用原有的逻辑
+      return await callControllerLegacy(ctx, controller, methods);
+   }
+}
+
+async function callControllerLegacy(ctx: Context, controller: any, methods: string) {
+   const callParam: any[] = [];
+   if (controller.$_MethdosParamInfo) {
+      const paramsInfo: undefined | { type: IParamTypeEnum, validate: any }[] = controller.$_MethdosParamInfo.get(methods);
+      if (paramsInfo && paramsInfo.length > 0) {
+         //  console.log(paramsInfo,"参数信息")
+         for (let paramInfo of paramsInfo) {
+
+            let data = undefined;
+            if (paramInfo.type == IParamTypeEnum.Body) {
+               data = ctx.request.body;
+            }
+
+            switch (paramInfo.type) {
+               case IParamTypeEnum.Body:
+                  data = ctx.request.body;
+                  break;
+               case IParamTypeEnum.Query:
+                  data = ctx.query;
+                  break;
+               case IParamTypeEnum.Params:
+                  data = ctx.params;
+                  break;
+               case IParamTypeEnum.Headers:
+                  data = ctx.request.headers;
+                  break;
+               case IParamTypeEnum.State:
+                  data = ctx.state;
+                  break;
+            }
+            //这里可以统一做参数校验（仅当 validate 为 DTO 类构造函数时）
+            if (paramInfo.validate && typeof paramInfo.validate === 'function') {
+               const waitToValidateObject = new paramInfo.validate();
+
+               for (let i in data) {
+                  if (waitToValidateObject.$_Transform && waitToValidateObject.$_Transform.get(i)) {
+                     const func = waitToValidateObject.$_Transform.get(i);
+                     const result = func(data[i]);
+                     if (isPromise(result)) {
+                        waitToValidateObject[i] = await result;
+                     } else {
+                        waitToValidateObject[i] = result;
+                     }
+                  } else {
+                     waitToValidateObject[i] = data[i]
+                  }
+               }
+
+               const validateErrors = await validate(waitToValidateObject);
+
+               if (validateErrors.length > 0) {
+                  ctx.status = 400;
+                  return ctx.body = validateErrors;
+               }
+            }
+            callParam.push(data);
+         }
+      }
+   }
+   // 调用controller
+   try {
+
+      let controllerCacheInfo: any = null;
+      if (controller.$_ControllerCache && controller.$_ControllerCache.get(methods)) {
+         const { cacheyFn, options } = controller.$_ControllerCache.get(methods);
+         if (options && (options.enable === undefined || options.enable)) {
+            const cacheKey = cacheyFn(...callParam);
+            if (cacheKey) {
+               const cacheResult = controllerResultCacheStore.get(cacheKey);
+               if (cacheResult) {
+                  return ctx.body = cacheResult;
+               }
+
+               controllerCacheInfo = {
+                  cacheyFn, options, cacheKey,
+               }
+            }
+         }
+
+
+
+
+      }
+
+      const callResult = controller[methods].apply(controller, callParam);
+      if (controller.$_ResponseCode) {
+         const code = controller.$_ResponseCode.get(methods) ?? 200;
+         ctx.status = code;
+      }
+      if (controller.$_ResponseHeader) {
+         const responseHeaders = controller.$_ResponseHeader.get(methods);
+         if (responseHeaders) {
+            responseHeaders.keys().forEach((key: string) => {
+               const value = responseHeaders.get(key);
+               if (value) {
+                  ctx.set(key, value);
+               }
+            });
+         }
+      }
+
+
+
+      if (isPromise(callResult)) {
+         const res = await callResult;
+         const resValidateResult = await responseValidate(controller, methods, res);
+         if (resValidateResult.length > 0) {
+            ctx.status = 400;
+            logger.error(resValidateResult.join(', '))
+            return ctx.body = `接口${methods}返回数据参数校验异常`;
+         }
+         ctx.body = res;
+      } else {
+         const resValidateResult = await responseValidate(controller, methods, callResult);
+         if (resValidateResult.length > 0) {
+            ctx.status = 400;
+            return ctx.body = resValidateResult;
+         }
+         ctx.body = callResult;
+      }
+
+      // 可以在这里 加入 控制器方法缓存的数据
+      if (controllerCacheInfo) {
+         // 创建缓存
+         const { options, cacheKey, } = controllerCacheInfo;
+         if (options && (options.enable === undefined || options.enable)) {
+            let ttl = 20;
+            if (options && options.ttl) {
+               if (options.ttl instanceof Object) {
+                  ttl = getRandoNumer(options.ttl.min, options.ttl.max)
+               }
+            }
+            controllerResultCacheStore.set(cacheKey, ctx.body, ttl)
+         }
+
+      }
+
+   } catch (err) {
+      throw err;
+      // 这里要抛出异常，并且以更详细的信息抛出来
+   }
+}
+/**
+ * 绑定路由
+ * @param path 路由路径
+ * @param controller 控制器
+ */
+export const bindRouter = (...args: any[]) => {
+   if (args.length < 2) {
+      throw new Error("路由绑定至少2个参数");
+   }
+   const _path: string = args[0];
+   const Controller: any = args[args.length - 1];
+
+   const middlewares: any = [];
+   //表示有中间件
+   if (args.length > 2) {
+      for (let i in args) {
+         let index = Number(i);
+         if (index != 0 && index != args.length - 1) {
+            middlewares.push(args[i]);
+         }
+      }
+   }
+
+   const controller = Provider<any>(Controller);
+   // 绑定post方法
+   if (controller.$_PostMethods) {
+      const postMethods: Array<{ methodName: string, url: string }> = Array.from(controller.$_PostMethods);
+      postMethods.forEach(_methods => {
+         const { methodName, url } = _methods;
+         const methods = methodName;
+         if (controller[methods]) {
+            const _url = path.join(_path, url).replace(/\\/g, "/");
+
+            const cb = async (ctx: any) => {
+               // 读取该方法的参数注解信息
+               await callController(ctx, controller, methods);
+            }
+            if (middlewares.length > 0) {
+               for (const middleware of middlewares) {
+                  _router.use(_url, middleware);
+               }
+            }
+            _router.post(_url, cb)
+            
+            // 如果URL以斜杠结尾，同时注册无斜杠版本
+            if (_url.endsWith('/') && _url !== '/') {
+               const urlWithoutSlash = _url.slice(0, -1);
+               if (middlewares.length > 0) {
+                  for (const middleware of middlewares) {
+                     _router.use(urlWithoutSlash, middleware);
+                  }
+               }
+               _router.post(urlWithoutSlash, cb)
+            }
+         }
+      })
+   }
+
+   // 绑定 get方法
+   if (controller.$_GetMethods) {
+      const postMethods: Array<{ methodName: string, url: string }> = Array.from(controller.$_GetMethods);
+      postMethods.forEach(_methods => {
+         const { methodName, url } = _methods;
+         const methods = methodName;
+         if (controller[methods]) {
+            const _url = path.join(_path, url).replace(/\\/g, "/");
+            const cb = async (ctx: any) => {
+               // 读取该方法的参数注解信息
+               await callController(ctx, controller, methods);
+            }
+            if (middlewares.length > 0) {
+               for (const middleware of middlewares) {
+                  _router.use(_url, middleware);
+               }
+            }
+            _router.get(_url, cb)
+            
+            // 如果URL以斜杠结尾，同时注册无斜杠版本
+            if (_url.endsWith('/') && _url !== '/') {
+               const urlWithoutSlash = _url.slice(0, -1);
+               if (middlewares.length > 0) {
+                  for (const middleware of middlewares) {
+                     _router.use(urlWithoutSlash, middleware);
+                  }
+               }
+               _router.get(urlWithoutSlash, cb)
+            }
+
+         }
+      })
+   }
+
+   // 绑定 put 方法
+   if (controller.$_PutMethods) {
+      const postMethods: Array<{ methodName: string, url: string }> = Array.from(controller.$_PutMethods);
+      postMethods.forEach(_methods => {
+         const { methodName, url } = _methods;
+         const methods = methodName;
+         if (controller[methods]) {
+            const _url = path.join(_path, url).replace(/\\/g, "/");
+
+            const cb = async (ctx: any) => {
+               // 读取该方法的参数注解信息
+               await callController(ctx, controller, methods);
+            }
+            if (middlewares.length > 0) {
+               for (const middleware of middlewares) {
+                  _router.use(_url, middleware);
+               }
+            }
+            _router.put(_url, cb)
+            
+            // 如果URL以斜杠结尾，同时注册无斜杠版本
+            if (_url.endsWith('/') && _url !== '/') {
+               const urlWithoutSlash = _url.slice(0, -1);
+               if (middlewares.length > 0) {
+                  for (const middleware of middlewares) {
+                     _router.use(urlWithoutSlash, middleware);
+                  }
+               }
+               _router.put(urlWithoutSlash, cb)
+            }
+         }
+      })
+   }
+
+   // 绑定 del 方法
+   if (controller.$_DelMethods) {
+      const postMethods: Array<{ methodName: string, url: string }> = Array.from(controller.$_DelMethods);
+      postMethods.forEach(_methods => {
+         const { methodName, url } = _methods;
+         const methods = methodName;
+         if (controller[methods]) {
+            const _url = path.join(_path, url).replace(/\\/g, "/");
+            const cb = async (ctx: any) => {
+               // 读取该方法的参数注解信息
+               await callController(ctx, controller, methods);
+            }
+            if (middlewares.length > 0) {
+               for (const middleware of middlewares) {
+                  _router.use(_url, middleware);
+               }
+            }
+            _router.del(_url, cb)
+            
+            // 如果URL以斜杠结尾，同时注册无斜杠版本
+            if (_url.endsWith('/') && _url !== '/') {
+               const urlWithoutSlash = _url.slice(0, -1);
+               if (middlewares.length > 0) {
+                  for (const middleware of middlewares) {
+                     _router.use(urlWithoutSlash, middleware);
+                  }
+               }
+               _router.del(urlWithoutSlash, cb)
+            }
+         }
+      })
+   }
+
+
+   // 绑定 all 方法
+   if (controller.$_AllMethods) {
+      const postMethods: Array<{ methodName: string, url: string }> = Array.from(controller.$_AllMethods);
+      postMethods.forEach(_methods => {
+         const { methodName, url } = _methods;
+         const methods = methodName;
+         if (controller[methods]) {
+            const _url = path.join(_path, url).replace(/\\/g, "/");
+            const cb = async (ctx: any) => {
+               // 读取该方法的参数注解信息
+               await callController(ctx, controller, methods);
+            }
+            if (middlewares.length > 0) {
+               for (const middleware of middlewares) {
+                  _router.use(_url, middleware);
+               }
+            }
+            _router.all(_url, cb)
+            
+            // 如果URL以斜杠结尾，同时注册无斜杠版本
+            if (_url.endsWith('/') && _url !== '/') {
+               const urlWithoutSlash = _url.slice(0, -1);
+               if (middlewares.length > 0) {
+                  for (const middleware of middlewares) {
+                     _router.use(urlWithoutSlash, middleware);
+                  }
+               }
+               _router.all(urlWithoutSlash, cb)
+            }
+         }
+      })
+   }
+
+}
+
+// 导出路由对象
+export const router = _router;