@mindbase/express-common 1.0.7 → 1.0.8

package/utils/InitDatabase.ts

@@ -0,0 +1,133 @@
+import path from "path";
+import fs from "fs";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import Database from "better-sqlite3";
+import { AppState } from "../core/state";
+import { ScanResult } from "../types/Index";
+import logger from "./Logger";
+
+/**
+ * 封装细节：从扫描结果中提取 Schema 并初始化数据库
+ * @param state 应用状态
+ * @param scannedResults 扫描结果
+ * @returns 数据库实例
+ * @throws 如果数据库设置失败
+ */
+export function setupDatabase(state: AppState, scannedResults: ScanResult[]) {
+  try {
+    if (!state) {
+      throw new Error("应用状态对象不能为空");
+    }
+
+    if (!Array.isArray(scannedResults)) {
+      throw new Error("扫描结果必须是一个数组");
+    }
+
+    const schemas: Record<string, any> = {};
+    for (const item of scannedResults) {
+      if (item.type === "schema" && item.allExports) {
+        try {
+          Object.assign(schemas, item.allExports);
+        } catch (e) {
+          logger.warn(`处理 Schema 文件失败: ${item.filePath}`, e);
+        }
+      }
+    }
+    state.schemas = schemas;
+
+    logger.startup("扫描", `提取到 ${Object.keys(schemas).length} 个 Schema 定义`);
+
+    return initDatabase({
+      schemas,
+      state,
+    });
+  } catch (error) {
+    logger.error("数据库设置失败：", error);
+    throw new Error(`数据库设置失败：${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * 初始化 SQLite 数据库
+ * @param options 配置选项
+ * @returns 数据库实例
+ * @throws 如果数据库初始化失败
+ */
+export function initDatabase(options: { schemas: Record<string, any>; dbPath?: string; state?: AppState }): any {
+  if (!options) {
+    throw new Error("初始化选项不能为空");
+  }
+
+  try {
+    const currentDir = process.cwd();
+    const dbPath = options.dbPath || options.state?.options?.database?.path || "./data/app.db";
+    const absoluteDbPath = path.resolve(currentDir, dbPath);
+    const dbDir = path.dirname(absoluteDbPath);
+
+    logger.startup("数据库", `初始化：路径=${absoluteDbPath}`);
+
+    // 确保目录存在
+    try {
+      if (!fs.existsSync(dbDir)) {
+        logger.startup("数据库", `创建目录：${dbDir}`);
+        fs.mkdirSync(dbDir, { recursive: true });
+      }
+    } catch (e) {
+      throw new Error(`创建数据库目录失败：${e instanceof Error ? e.message : String(e)}`);
+    }
+
+    // 初始化 SQLite 数据库
+    let sqlite: Database.Database;
+    try {
+      sqlite = new Database(absoluteDbPath);
+    } catch (e) {
+      throw new Error(`连接数据库失败：${e instanceof Error ? e.message : String(e)}`);
+    }
+
+    // SQLite 性能优化设置
+    try {
+      // 写前日志模式（提升并发性能）
+      sqlite.pragma("journal_mode = WAL");
+      // 同步模式（安全性与性能平衡）
+      sqlite.pragma("synchronous = NORMAL");
+      // 页面缓存：1GB（负值表示 KB）
+      sqlite.pragma("cache_size = -1048576");
+      // 临时表使用内存
+      sqlite.pragma("temp_store = MEMORY");
+      // 页面大小：4KB
+      sqlite.pragma("page_size = 4096");
+      // WAL 自动检查点阈值（减少刷盘频率）
+      sqlite.pragma("wal_autocheckpoint = 10000");
+      // 忙等待超时：5秒
+      sqlite.pragma("busy_timeout = 5000");
+    } catch (e) {
+      logger.warn("设置 SQLite 性能参数失败：", e);
+      // 继续执行，不中断初始化
+    }
+
+    // 初始化 Drizzle
+    let db: any;
+    try {
+      db = drizzle(sqlite, { schema: options.schemas || {} });
+    } catch (e) {
+      // 关闭 SQLite 连接
+      try {
+        sqlite.close();
+      } catch (closeError) {
+        logger.warn("关闭数据库连接失败：", closeError);
+      }
+      throw new Error(`初始化 Drizzle ORM 失败：${e instanceof Error ? e.message : String(e)}`);
+    }
+
+    // 如果提供了状态对象，更新它
+    if (options.state) {
+      options.state.db = db;
+    }
+
+    return db;
+  } catch (error) {
+    logger.error("数据库初始化失败：", error);
+    throw new Error(`数据库初始化失败：${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/utils/InitErrorHandler.ts

@@ -0,0 +1,82 @@
+import { Request, Response, NextFunction, Express } from "express";
+import { ZodError } from "zod";
+import logger from "./Logger";
+
+/**
+ * 检测是否为 SQL 相关错误（表/字段不存在）
+ */
+function isSQLError(err: any): boolean {
+  if (!err) return false;
+  const msg = err.message || err.toString() || "";
+  return /no such table|table.*does not exist|column.*does not exist|database schema has changed/i.test(msg);
+}
+
+/**
+ * 封装细节：初始化错误处理和 404 中间件
+ */
+export function setupErrorHandlers(app: Express, logging?: boolean) {
+  // 404 处理
+  app.use((req: Request, res: Response) => {
+    res.status(404).json({
+      code: 404,
+      data: null,
+      msg: "资源不存在",
+      error: "Not Found",
+      fields: {},
+    });
+  });
+
+  // 错误处理
+  app.use((err: any, req: Request, res: Response, next: NextFunction) => {
+    // 处理业务错误（带有 isAppError 标记或 4xx 状态码）
+    if (err.isAppError || (err.statusCode && err.statusCode >= 400 && err.statusCode < 500)) {
+      return res.status(err.statusCode).json({
+        code: err.statusCode,
+        data: null,
+        msg: err.message,
+        error: "BusinessError",
+        fields: {},
+      });
+    }
+
+    // 处理 Zod 校验错误
+    if (err instanceof ZodError) {
+      const fields: Record<string, string> = {};
+      err.errors.forEach((e) => {
+        const path = e.path.join(".");
+        fields[path] = e.message;
+      });
+
+      return res.status(400).json({
+        code: 400,
+        data: null,
+        msg: "参数校验失败",
+        error: "ZodValidationError",
+        fields,
+      });
+    }
+
+    // 处理 SQL 错误（给出友好提示）
+    if (isSQLError(err)) {
+      logger.error("");
+      logger.error("❌ 数据库结构可能已变化，请运行以下命令同步：");
+      logger.error("");
+      logger.error("   npm run db:migrate");
+      logger.error("");
+    }
+
+    // 处理普通错误
+    const statusCode = err.status || err.statusCode || 500;
+    if (!isSQLError(err)) {
+      logger.error("系统错误:", err);
+    }
+
+    res.status(statusCode).json({
+      code: statusCode,
+      data: null,
+      msg: err.message || "服务器内部错误",
+      error: logging ? err.stack : "InternalServerError",
+      fields: {},
+    });
+  });
+}

package/utils/InitExpress.ts

@@ -0,0 +1,38 @@
+import express, { Express } from "express";
+import fs from "fs";
+import cookieParser from "cookie-parser";
+import cors from "../middleware/Cors";
+import ipParser from "../middleware/IpParser";
+import uaParser from "../middleware/UaParser";
+import { AppState } from "../types/Index";
+import logger from "./Logger";
+
+export default function initExpress(mindBaseState: AppState): void {
+  const app = mindBaseState.express;
+  const options = mindBaseState.options;
+  app.getDB = () => mindBaseState.db;
+  app.configs = mindBaseState.options;
+  app.disable("x-powered-by");
+  app.use(express.urlencoded({ extended: false, limit: "10mb" }));
+  app.use(express.json({ limit: "10mb" }));
+  app.use(cookieParser());
+  if (options.staticPath) {
+    if (!fs.existsSync(options.staticPath)) {
+      fs.mkdirSync(options.staticPath, { recursive: true });
+    }
+    app.use(express.static(options.staticPath));
+    logger.startup("设置", `静态目录: ${options.staticPath}`);
+  }
+  if (options.cors) {
+    app.use(cors);
+    logger.startup("设置", "跨域请求头");
+  }
+  if (options.ip) {
+    logger.startup("设置", "IP地址解析");
+    app.use(ipParser);
+  }
+  if (options.userAgent) {
+    logger.startup("设置", "用户代理解析");
+    app.use(uaParser);
+  }
+}

package/utils/Logger.ts

@@ -0,0 +1,206 @@
+import dayjs from "./Dayjs";
+
+export type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+
+const LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4,
+} as const;
+
+let currentLogLevel: LogLevel = "info";
+
+const COLORS = {
+  debug: "\x1b[36m",
+  info: "\x1b[32m",
+  warn: "\x1b[33m",
+  error: "\x1b[31m",
+  reset: "\x1b[0m",
+} as const;
+
+/**
+ * 计算字符串在终端中的视觉宽度
+ * 修复：区分单宽符号 (如 ✓) 和双宽符号 (如 中文、Emoji)
+ */
+function getVisualWidth(str: string): number {
+  let width = 0;
+  const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+  for (const { segment } of segmenter.segment(str)) {
+    const charCode = segment.charCodeAt(0);
+
+    // 1. 基础 ASCII
+    if (charCode <= 255) {
+      width += 1;
+      continue;
+    }
+
+    // 2. CJK 字符集范围 (常用中文、标点、全角符号)
+    const isCJK =
+      (charCode >= 0x4e00 && charCode <= 0x9fff) || // CJK Unified Ideographs
+      (charCode >= 0x3000 && charCode <= 0x303f) || // CJK Symbols and Punctuation
+      (charCode >= 0xff00 && charCode <= 0xffef); // Fullwidth Forms
+
+    // 3. Emoji 或代理对 (通常 segment.length > 1)
+    const isMultiByte = segment.length > 1;
+
+    if (isCJK || isMultiByte) {
+      width += 2;
+    } else {
+      // 4. 其他特殊符号 (如 ✓, ★, ☎) 在大多数终端占 1 格
+      width += 1;
+    }
+  }
+  return width;
+}
+
+/**
+ * 截断字符串以适应视觉宽度，从头部截断并保留末尾
+ */
+function truncateToWidth(str: string, maxWidth: number): string {
+  const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+  const segments = Array.from(segmenter.segment(str)).map((s) => s.segment);
+
+  if (getVisualWidth(str) <= maxWidth) return str;
+
+  let currentWidth = 3; // 为 "..." 预留
+  let result = "";
+
+  // 从后往前遍历 segments
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i];
+    const segmentWidth = getVisualWidth(segment);
+    if (currentWidth + segmentWidth > maxWidth) break;
+    result = segment + result;
+    currentWidth += segmentWidth;
+  }
+  return "..." + result;
+}
+
+function formatMessage(level: LogLevel, message: string): string {
+  const timestamp = dayjs().format("YYYY-MM-DD HH:mm:ss");
+  const terminalWidth = process.stdout.columns || 80;
+  const timeStr = ` ${timestamp}`;
+  const timeWidth = getVisualWidth(timeStr);
+  const maxMessageWidth = terminalWidth - timeWidth - 2;
+
+  let displayMessage = message;
+  const messageWidth = getVisualWidth(displayMessage);
+
+  if (messageWidth > maxMessageWidth) {
+    displayMessage = truncateToWidth(displayMessage, maxMessageWidth);
+  }
+
+  const currentMsgWidth = getVisualWidth(displayMessage);
+  const paddingCount = Math.max(0, terminalWidth - currentMsgWidth - timeWidth);
+  const padding = " ".repeat(paddingCount);
+
+  return `${COLORS[level]}${displayMessage}${padding}${timeStr}${COLORS.reset}`;
+}
+
+const startupTime = Date.now();
+
+// 标签填充函数（目标显示宽度 8，空格分散到字符间）
+function padTag(tag: string, targetWidth = 8): string {
+  const currentWidth = getVisualWidth(tag);
+  const padding = Math.max(0, targetWidth - currentWidth);
+
+  if (padding === 0) return tag;
+
+  // 将空格均匀分散到字符之间
+  const chars = [...tag]; // 按码点分割
+  const gapCount = chars.length + 1; // 间隙数 = 字符数 + 1（前后和中间）
+
+  // 计算每个间隙的空格数
+  const baseSpaces = Math.floor(padding / gapCount);
+  const extraSpaces = padding % gapCount;
+
+  let result = "";
+  for (let i = 0; i < chars.length; i++) {
+    // 每个间隙的空格 = 基础空格 + 额外空格（前 extraSpaces 个间隙多1个）
+    const spaces = baseSpaces + (i < extraSpaces ? 1 : 0);
+    result += " ".repeat(spaces) + chars[i];
+  }
+  // 最后一个间隙
+  result += " ".repeat(baseSpaces + (chars.length < extraSpaces ? 1 : 0));
+
+  return result;
+}
+
+function startupMessage(message: string, tag?: string): string {
+  const diff = Date.now() - startupTime;
+  const timeStr = diff.toString().padStart(6, "0");
+  const tagStr = tag ? `【${padTag(tag)}】` : "";
+  return `${COLORS["warn"]}[${timeStr}] ${tagStr}${message}${COLORS["reset"]}`;
+}
+
+function shouldLog(level: LogLevel): boolean {
+  return LOG_LEVELS[level] >= LOG_LEVELS[currentLogLevel];
+}
+
+function formatArgs(args: any[]): string {
+  return args
+    .map((arg) => {
+      if (arg instanceof Error) {
+        return arg.message;
+      }
+      if (typeof arg === "object") {
+        return JSON.stringify(arg, null, 2);
+      }
+      return String(arg);
+    })
+    .join(" ");
+}
+
+export const logger = {
+  debug(...args: any[]): void {
+    if (shouldLog("debug")) {
+      console.log(formatMessage("debug", formatArgs(args)));
+    }
+  },
+
+  info(...args: any[]): void {
+    if (shouldLog("info")) {
+      console.log(formatMessage("info", formatArgs(args)));
+    }
+  },
+
+  warn(...args: any[]): void {
+    if (shouldLog("warn")) {
+      console.warn(formatMessage("warn", formatArgs(args)));
+    }
+  },
+
+  error(...args: any[]): void {
+    if (shouldLog("error")) {
+      // 先打印带颜色的格式化消息
+      console.error(formatMessage("error", formatArgs(args)));
+      // 如果有 Error 对象，用 console.error 单独打印以显示堆栈
+      const errorArg = args.find((arg) => arg instanceof Error);
+      if (errorArg) {
+        console.error(errorArg);
+      }
+    }
+  },
+
+  startup(tagOrMessage: string, ...args: any[]): void {
+    // 如果有额外参数，第一个是标签，其余是消息
+    // 否则第一个参数是消息，无标签
+    if (args.length > 0) {
+      console.log(startupMessage(formatArgs(args), tagOrMessage));
+    } else {
+      console.log(startupMessage(tagOrMessage));
+    }
+  },
+
+  setLevel(level: LogLevel): void {
+    currentLogLevel = level;
+  },
+
+  getLevel(): LogLevel {
+    return currentLogLevel;
+  },
+};
+
+export default logger;

package/utils/MiddlewareRegistry.ts

@@ -0,0 +1,14 @@
+import { Express } from "express";
+import { ScanResult } from "../types/Index";
+import logger from "./Logger";
+
+export async function registerMiddleware(app: Express, config: ScanResult): Promise<void> {
+  const { fileName = "anonymous", defaultExport: handler } = config;
+
+  try {
+    app.use(handler);
+    logger.startup("中间件", `注册: ${fileName}`);
+  } catch (error) {
+    logger.error(`注册中间件失败 ${fileName}:`, error);
+  }
+}