create-dp-koa 1.1.1 → 1.1.3

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

@@ -1,148 +0,0 @@
-import { DataSourceOptions } from "typeorm";
-import { logger } from "@src/framework/utils/logger";
-import { APP_MIGRATIONS } from "@src/migrations";
-import { isDebug } from "@src/framework/utils/function";
-
-/**
- * 数据库配置工具
- * 框架级别的数据库配置管理
- */
-export class DatabaseConfigManager {
-    private static instance: DatabaseConfigManager;
-
-    private constructor() {}
-
-    static getInstance(): DatabaseConfigManager {
-        if (!DatabaseConfigManager.instance) {
-            DatabaseConfigManager.instance = new DatabaseConfigManager();
-        }
-        return DatabaseConfigManager.instance;
-    }
-
-    /**
-     * 检查是否启用数据库
-     */
-    isDatabaseEnabled(): boolean {
-        // 在内存数据库模式下也启用数据库
-        if (this.isMemoryDatabaseMode()) {
-            return true;
-        }
-        return Number(process.env.db_enable) == 1;
-    }
-
-    /**
-     * 检查是否为内存数据库模式
-     */
-    isMemoryDatabaseMode(): boolean {
-        return Number(process.env.db_memory) == 1;
-    }
-
-    /**
-     * 获取数据库类型（postgres | mysql），仅非内存模式时有效
-     */
-    private getDbType(): 'postgres' | 'mysql' {
-        const t = (process.env.db_type || 'postgres').toLowerCase();
-        return t === 'mysql' ? 'mysql' : 'postgres';
-    }
-
-    /**
-     * 获取数据库配置
-     * @param entities 实体列表
-     * 内存模式：SQLite 内存（单元测试保持此方案）；否则按 db_type 使用 PostgreSQL 或 MySQL
-     */
-    getDatabaseConfig(entities: any[]): DataSourceOptions {
-        if (this.isMemoryDatabaseMode()) {
-            logger.info("启用内存数据库模式（SQLite）");
-            return this.getMemoryDatabaseConfig(entities);
-        }
-        const dbType = this.getDbType();
-        if (dbType === 'postgres') {
-            logger.info("启用 PostgreSQL 数据库模式");
-            return this.getPostgresDatabaseConfig(entities);
-        }
-        logger.info("启用 MySQL 数据库模式");
-        return this.getMySQLDatabaseConfig(entities);
-    }
-
-    /**
-     * 获取内存数据库配置
-     * 使用 SQLite 内存数据库，适合开发和测试环境
-     */
-    private getMemoryDatabaseConfig(entities: any[]): DataSourceOptions {
-        // 使用 SQLite 内存数据库
-        return {
-            type: "sqlite",
-            database: ":memory:", // SQLite 内存数据库
-            entities: entities,
-            synchronize: true,
-            logging: false,
-            dropSchema: true, // 每次启动时重新创建表结构
-        };
-    }
-
-    /**
-     * 获取 PostgreSQL 数据库配置（dev/debug 推荐）
-     */
-    private getPostgresDatabaseConfig(entities: any[]): DataSourceOptions {
-        const debug = isDebug();
-        return {
-            type: "postgres",
-            host: process.env.db_host ?? "127.0.0.1",
-            port: parseInt(process.env.db_port || "5432", 10),
-            username: process.env.db_username ?? "admin",
-            password: process.env.db_password ?? "",
-            database: process.env.db_database ?? "mydb",
-            entities: entities,
-            // 非 debug（生产口径）关闭自动同步，避免与 migration 冲突
-            synchronize: debug,
-            logging: process.env.db_logging === "1",
-            migrations: APP_MIGRATIONS,
-            migrationsRun: false,
-            migrationsTableName: "migrations",
-        };
-    }
-
-    /**
-     * 获取 MySQL 数据库配置
-     */
-    private getMySQLDatabaseConfig(entities: any[]): DataSourceOptions {
-        const debug = isDebug();
-        return {
-            type: "mysql",
-            connectorPackage: "mysql2",
-            host: process.env?.db_host ?? "127.0.0.1",
-            port: parseInt(process.env.db_port || "3306", 10),
-            username: process.env?.db_username ?? "test",
-            password: process.env?.db_password ?? "test",
-            database: process.env?.db_database ?? "test",
-            entities: entities,
-            // 非 debug（生产口径）关闭自动同步，避免与 migration 冲突
-            synchronize: debug,
-            logging: false,
-            migrations: APP_MIGRATIONS,
-            migrationsRun: false,
-            migrationsTableName: "migrations",
-        };
-    }
-
-    /**
-     * 获取数据库类型描述
-     */
-    getDatabaseTypeDescription(): string {
-        if (this.isMemoryDatabaseMode()) {
-            return "内存数据库（SQLite）";
-        }
-        return this.getDbType() === "postgres" ? "PostgreSQL" : "MySQL";
-    }
-
-    /**
-     * 检查是否需要数据库监控
-     * 内存数据库不需要连接池监控
-     */
-    needsDatabaseMonitoring(): boolean {
-        return this.isDatabaseEnabled() && !this.isMemoryDatabaseMode();
-    }
-}
-
-// 导出单例实例
-export const databaseConfigManager = DatabaseConfigManager.getInstance();

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

@@ -1,39 +0,0 @@
-import { DataSource, DataSourceOptions } from "typeorm"
-import { logger } from "@src/framework/utils/logger"
-
-var _MysqlDataSource: DataSource | null = null;
-
-export const initDb = async (option: DataSourceOptions) => {
-    _MysqlDataSource = new DataSource(option);
-    return _MysqlDataSource.initialize();
-}
-
-export const getDataSource = (): DataSource | null => {
-    return _MysqlDataSource
-}
-
-/**
- * 关闭数据库连接
- * 在应用关闭时调用，确保数据库连接池被正确释放
- */
-export const closeDb = async (): Promise<void> => {
-    if (_MysqlDataSource && _MysqlDataSource.isInitialized) {
-        try {
-            await _MysqlDataSource.destroy();
-            _MysqlDataSource = null;
-            logger.info("数据库连接已关闭");
-        } catch (error) {
-            logger.error("关闭数据库连接时发生错误:", error as Error);
-            throw error;
-        }
-    } else {
-        logger.info("数据库连接未初始化或已关闭");
-    }
-}
-
-/**
- * 检查数据库连接状态
- */
-export const isDbConnected = (): boolean => {
-    return _MysqlDataSource !== null && _MysqlDataSource.isInitialized;
-}

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

@@ -1,106 +0,0 @@
-import { logger } from "@src/framework/utils/logger";
-import { getDataSource, isDbConnected } from "@src/framework/utils/db";
-
-/**
- * 数据库连接监控工具
- */
-export class DbMonitor {
-    private static instance: DbMonitor;
-    private monitorInterval: NodeJS.Timeout | null = null;
-
-    private constructor() {}
-
-    static getInstance(): DbMonitor {
-        if (!DbMonitor.instance) {
-            DbMonitor.instance = new DbMonitor();
-        }
-        return DbMonitor.instance;
-    }
-
-    /**
-     * 开始监控数据库连接状态
-     * @param intervalMs 监控间隔（毫秒），默认30秒
-     */
-    startMonitoring(intervalMs: number = 30000): void {
-        if (this.monitorInterval) {
-            logger.warn("数据库监控已在运行中");
-            return;
-        }
-
-        this.monitorInterval = setInterval(async () => {
-            try {
-                const isConnected = isDbConnected();
-                const dataSource = getDataSource();
-                
-                if (isConnected && dataSource) {
-                    // 检查是否为内存数据库
-                    const driver = (dataSource as any).driver;
-                    if (driver && driver.options && driver.options.database === ':memory:') {
-                        logger.debug("内存数据库连接正常");
-                    } else {
-                        await dataSource.query('SELECT 1');
-                        const dbType = (dataSource as any).options?.type ?? 'mysql';
-                        logger.debug(`${dbType} 数据库连接正常`);
-                    }
-                } else {
-                    logger.warn("数据库连接异常");
-                }
-            } catch (error) {
-                logger.error("数据库连接检查失败:", error as Error);
-            }
-        }, intervalMs);
-
-        logger.info(`数据库连接监控已启动，监控间隔: ${intervalMs}ms`);
-    }
-
-    /**
-     * 停止监控
-     */
-    stopMonitoring(): void {
-        if (this.monitorInterval) {
-            clearInterval(this.monitorInterval);
-            this.monitorInterval = null;
-            logger.info("数据库连接监控已停止");
-        }
-    }
-
-    /**
-     * 获取数据库连接池状态
-     */
-    async getConnectionPoolStatus(): Promise<any> {
-        const dataSource = getDataSource();
-        if (!dataSource || !dataSource.isInitialized) {
-            return { status: 'disconnected' };
-        }
-
-        try {
-            // 检查是否为内存数据库
-            const driver = (dataSource as any).driver;
-            if (driver && driver.options && driver.options.database === ':memory:') {
-                return {
-                    status: 'connected',
-                    type: 'memory',
-                    message: '内存数据库模式'
-                };
-            }
-
-            const dbType = (dataSource as any).options?.type ?? 'mysql';
-            if (driver && driver.pool) {
-                return {
-                    status: 'connected',
-                    type: dbType,
-                    totalConnections: driver.pool._allConnections?.length || 0,
-                    freeConnections: driver.pool._freeConnections?.length || 0,
-                    usedConnections: driver.pool._usedConnections?.length || 0
-                };
-            }
-            return { status: 'connected', type: dbType, poolInfo: 'unavailable' };
-        } catch (error) {
-            logger.error("获取连接池状态失败:", error as Error);
-            return { status: 'error', error: error instanceof Error ? error.message : '未知错误' };
-        }
-    }
-}
-
-// 导出单例实例
-export const dbMonitor = DbMonitor.getInstance();

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

@@ -1,61 +0,0 @@
-import path from "path"
-
-/**
- * 判断当前是否为调试环境
- */
-export function isDebug(): boolean {
-    let argv = new Set(process.argv)
-    if (argv.has("--env=debug")) {
-        return true
-    }
-    return false
-}
-
-/**
- * 与 NODE_ENV 解耦的运行环境标识（日志/配置元数据等）
- * - 启动参数含 `--env=debug` → development
- * - 否则 → production（非 debug 即生产口径）
- */
-export function getRuntimeEnvironmentLabel(): 'development' | 'production' {
-    return isDebug() ? 'development' : 'production'
-}
-
-
-/**
- * 根据文件夹获取项目目录的全路径
- * @param relativePath 
- */
-export function getFullPath(relativePath: string): string {
-    return path.join(process.cwd(), relativePath)
-}
-
-/**
- * 休眠
- * @param time 毫秒
- */
-export function sleep(time: number) {
-    return new Promise((resolve) => {
-        setTimeout(() => {
-            resolve("")
-        }, time);
-    })
-}
-
-/**
- * 判断Promise
- * @param obj 
- * @returns 
- */
-export function isPromise(obj: any) {
-    return !!obj && typeof obj.then === 'function' && typeof obj.catch === 'function';
-}
-
-
-/**
- * 生成一定范围内的随机数
- * @param start 
- * @param end 
- */
-export function getRandoNumer(start: number, end: number): number {
-	return Math.floor(Math.random() * (end - start + 1)) + start
-}

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

@@ -1,131 +0,0 @@
-import { closeServer } from '@src/framework/utils/bootstrap';
-
-export type ShutdownReason = 'SIGTERM' | 'SIGINT' | 'uncaughtException' | 'unhandledRejection';
-
-export type ShutdownHook = () => void | Promise<void>;
-
-export interface ShutdownLogger {
-  // 兼容项目内 EnterpriseLogger（通常为 info(message, context?) / error(message, error?, context?)）
-  info: (message: string, context?: any) => void;
-  warn?: (message: string, context?: any) => void;
-  error: (message: string, error?: Error, context?: any) => void;
-}
-
-export interface GracefulShutdownControllerOptions {
-  logger: ShutdownLogger;
-  /**
-   * 超时后强制退出，避免资源卡死导致进程无法停止
-   */
-  timeoutMs?: number;
-  /**
-   * 关闭 HTTP server（stop accepting new connections）
-   * 默认为 true
-   */
-  closeHttpServerFirst?: boolean;
-}
-
-type HookItem = { name: string; hook: ShutdownHook };
-
-const toError = (value: unknown): Error => {
-  if (value instanceof Error) return value;
-  if (typeof value === 'string') return new Error(value);
-
-  if (value && typeof value === 'object') {
-    const maybeMessage = (value as any).message;
-    if (typeof maybeMessage === 'string' && maybeMessage.trim()) {
-      return new Error(maybeMessage);
-    }
-  }
-
-  try {
-    return new Error(JSON.stringify(value));
-  } catch {
-    return new Error(String(value));
-  }
-};
-
-/**
- * 优雅关闭控制器：
- * - 统一注册 SIGTERM/SIGINT/uncaughtException/unhandledRejection
- * - 确保只触发一次
- * - 按注册顺序依次执行 hook（可用于清理 db/cache/monitor 等）
- */
-export const createGracefulShutdownController = (options: GracefulShutdownControllerOptions) => {
-  const { logger, timeoutMs = 15_000, closeHttpServerFirst = true } = options;
-
-  let registered = false;
-  let shuttingDown = false;
-  const hooks: HookItem[] = [];
-
-  const addHook = (name: string, hook: ShutdownHook) => {
-    hooks.push({ name, hook });
-  };
-
-  const runHooks = async (reason: ShutdownReason, err?: unknown) => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-
-    logger.info(`收到 ${reason} 信号，开始优雅关闭...`);
-    if (err) {
-      logger.error(`触发优雅关闭时携带异常（${reason}）`, toError(err));
-    }
-
-    const timer = setTimeout(() => {
-      logger.error(`优雅关闭超时（${timeoutMs}ms），强制退出`);
-      // eslint-disable-next-line n/no-process-exit
-      process.exit(1);
-    }, timeoutMs);
-    // 让 timer 不阻止进程退出
-    timer.unref?.();
-
-    let exitCode = 0;
-
-    try {
-      if (closeHttpServerFirst) {
-        try {
-          await closeServer();
-        } catch (e) {
-          exitCode = 1;
-          logger.error('关闭 HTTP Server 失败', toError(e));
-        }
-      }
-
-      for (const item of hooks) {
-        try {
-          await item.hook();
-        } catch (e) {
-          exitCode = 1;
-          logger.error(`执行关闭钩子失败: ${item.name}`, toError(e));
-        }
-      }
-
-      logger.info('优雅关闭完成');
-    } finally {
-      clearTimeout(timer);
-      // eslint-disable-next-line n/no-process-exit
-      process.exit(exitCode);
-    }
-  };
-
-  const register = () => {
-    if (registered) return;
-    registered = true;
-
-    process.on('SIGTERM', () => runHooks('SIGTERM'));
-    process.on('SIGINT', () => runHooks('SIGINT'));
-
-    process.on('uncaughtException', (error) => {
-      logger.error('未捕获的异常:', error);
-      runHooks('uncaughtException', error);
-    });
-
-    process.on('unhandledRejection', (reason) => {
-      logger.error('未处理的 Promise 拒绝:', toError(reason));
-      runHooks('unhandledRejection', reason);
-    });
-  };
-
-  return { addHook, register };
-};
-
-