@mindbase/express-common 1.0.0 → 1.0.2

package/core/app.ts

@@ -1,200 +0,0 @@
-import { Express } from "express";
-import { createState } from "./state";
-import { setBaseDir, scan, addScanPath } from "../feature/scanner/FileScanner";
-import { MindBaseAppOptions } from "../types/Index";
-import initExpress from "../utils/InitExpress";
-import { setupDatabase, handleDatabaseMigration } from "../utils/InitDatabase";
-import { checkAndMigrateDatabase } from "../utils/DatabaseMigration";
-import { registerComponents } from "../utils/ComponentRegistry";
-import { setupErrorHandlers } from "../utils/InitErrorHandler";
-import { handleSchemaSync } from "../utils/SchemaSync";
-import { handleSchemaMigrate } from "../utils/SchemaMigrate";
-import { startServer } from "../utils/HttpServer";
-import logger from "../utils/Logger";
-import { initDocManager } from "../utils/DocManager";
-
-/**
- * MindBase 应用实例
- */
-export interface MindBaseApp {
-  /** 注册插件模块 */
-  use(plugin: any): void;
-  /** 启动应用（初始化数据库、注册路由、启动 HTTP 服务） */
-  startup(): Promise<void>;
-  /** 获取 Express 实例 */
-  getApp(): Express;
-  /** 获取 Drizzle 数据库实例 */
-  getDB(): any;
-  /** 获取应用配置选项 */
-  getOptions(): MindBaseAppOptions;
-}
-
-/**
- * 创建 MindBase 应用实例
- * @param options 应用配置选项
- * @returns MindBase 应用实例
- * @example
- * const app = createApp({
- *   port: 3000,
- *   logLevel: "debug",
- * });
- * app.use(auth);
- * await app.startup();
- */
-export function createApp(options: MindBaseAppOptions = {}): MindBaseApp {
-  logger.startup("初始化", "应用初始化……");
-  const stateInstance = createState(options);
-  const plugins: any[] = [];
-
-  // 初始化日志级别
-  if (stateInstance.options.logLevel) {
-    logger.setLevel(stateInstance.options.logLevel);
-  }
-
-  const app: MindBaseApp = {
-    use: async (plugin) => {
-      if (typeof plugin.install === "function") {
-        plugins.push(plugin);
-      }
-      if (typeof plugin.__modulePath === "string") {
-        logger.startup("模块", `注册：${plugin.__modulePath}`);
-        addScanPath(plugin.__modulePath);
-      }
-    },
-    startup: async () => {
-      // migrate 模式：收集 schema + 执行 push（一体化迁移）
-      if (stateInstance.options.mode === "migrate") {
-        await handleSchemaMigrate();
-        return;
-      }
-
-      // sync 模式：仅收集 schema 路径（兼容旧版本）
-      if (stateInstance.options.mode === "sync") {
-        await handleSchemaSync();
-        return;
-      }
-
-      // 0. 初始化 Express 基础配置
-      initExpress(stateInstance.express, stateInstance.options);
-
-      // 1. 准备扫描环境
-      await prepareScanEnvironment();
-
-      // 2. 扫描组件
-      const scannedResults = await scanComponents();
-
-      // 3. 初始化数据存储
-      await initializeDataStorage(scannedResults);
-
-      // 4. 执行插件安装 (此时 DB 已就绪)
-      await installPlugins();
-
-      // 5. 注册组件
-      registerComponents(stateInstance, scannedResults);
-
-      // 6. 注册错误处理
-      setupErrorHandlers(stateInstance.express, stateInstance.options.logging);
-
-      // 7. 启动 HTTP 服务
-      await startHttpServer();
-
-      logger.startup("初始化", "✅ 应用启动完成");
-    },
-
-    getApp: () => stateInstance.express,
-    getDB: () => stateInstance.db,
-    getOptions: () => stateInstance.options,
-  };
-
-  // 准备扫描环境
-  async function prepareScanEnvironment() {
-    setBaseDir(process.cwd());
-    logger.startup("扫描", `基准目录: ${process.cwd()}`);
-  }
-
-  // 扫描组件
-  async function scanComponents() {
-    const scannedResults = await scan();
-
-    // 统计缓存命中情况
-    const routeFiles = scannedResults.filter(r => r.type === "route");
-    const cacheHits = routeFiles.filter(r => r.cacheHit).length;
-    const total = routeFiles.length;
-
-    if (cacheHits > 0) {
-      logger.startup("扫描", `发现 ${scannedResults.length} 个组件文件 (缓存命中: ${cacheHits}/${total})`);
-    } else {
-      logger.startup("扫描", `发现 ${scannedResults.length} 个组件文件`);
-    }
-
-    return scannedResults;
-  }
-
-  // 初始化数据存储
-  async function initializeDataStorage(scannedResults) {
-    // 初始化数据库与 Schema
-    setupDatabase(stateInstance, scannedResults);
-    stateInstance.express.set("db", stateInstance.db);
-
-    // 收集数据库信息
-    if (stateInstance.db) {
-      const dbPath = stateInstance.options.database?.path || "./data/app.db";
-      logger.startup("数据库", `已连接: SQLite (${dbPath})`);
-    }
-
-    // 数据库迁移已改为独立命令（npm run db:migrate）
-    // 不再在启动时自动执行，以提升启动速度
-    // await handleDatabaseMigrationStep();
-
-    // 初始化文档管理器
-    const docDbPath = stateInstance.options.database?.path ? stateInstance.options.database.path.replace(/app\.db$/, "doc.db") : "./data/doc.db";
-    initDocManager({ path: docDbPath });
-    logger.startup("数据库", `文档库已初始化: ${docDbPath}`);
-  }
-
-  // 处理数据库迁移
-  async function handleDatabaseMigrationStep() {
-    if (stateInstance.options.autoMigrate !== false) {
-      try {
-        await checkAndMigrateDatabase(stateInstance);
-        // 已在 DatabaseMigration 中打印日志，无需额外处理
-      } catch (error) {
-        logger.error("❌ 数据库结构检查失败:", error);
-      }
-    } else {
-      // 只提醒，不执行迁移
-      try {
-        await handleDatabaseMigration(stateInstance.db, stateInstance.schemas);
-      } catch (error) {
-        logger.error("❌ 数据库结构检查失败:", error);
-      }
-    }
-  }
-
-  // 执行插件安装
-  async function installPlugins() {
-    for (const plugin of plugins) {
-      await plugin.install(app);
-    }
-  }
-
-  // 启动 HTTP 服务
-  async function startHttpServer() {
-    const listenPort = stateInstance.options.port || 3000;
-    await startServer(stateInstance.express, listenPort);
-
-    // 打印服务器启动信息
-    const serverUrl = `http://localhost:${listenPort}`;
-    logger.startup("服务", `监听端口: ${listenPort}`);
-    logger.startup("服务", `访问地址: ${serverUrl}`);
-  }
-
-  return app;
-}
-
-// 扩展 Express Application 类型，添加 getDB 方法
-declare module "express" {
-  export interface Application {
-    getDB(): any;
-  }
-}

package/core/module/CreateModule.ts

@@ -1,38 +0,0 @@
-import { findPackageRoot } from "./FindPackageRoot";
-import { getModulePath } from "./GetModulePath";
-import { LightUpApp } from "../../types";
-import logger from "../../utils/Logger";
-
-export interface LightUpModule {
-  install(app: LightUpApp): Promise<void>;
-  __modulePath: string;
-}
-
-/**
- * 创建一个 LightUp 模块
- * @param install 模块安装函数
- * @param callerPath 调用者的文件路径（通常是 __filename），如果不提供则尝试通过调用栈获取
- * @returns LightUp 模块实例
- * @throws 如果模块创建失败
- */
-export function createModule(install, callerPath?: string): LightUpModule {
-  if (typeof install !== "function") {
-    throw new Error("模块安装函数必须是一个函数");
-  }
-
-  try {
-    // 优先使用传入的 callerPath，否则通过调用栈获取
-    const modulePath = callerPath || getModulePath();
-    const packageRoot = findPackageRoot(modulePath);
-
-    logger.debug(`创建模块：路径=${modulePath}，包根目录=${packageRoot}`);
-
-    return {
-      install,
-      __modulePath: packageRoot,
-    };
-  } catch (error) {
-    logger.error("模块创建失败：", error);
-    throw new Error(`模块创建失败：${error instanceof Error ? error.message : String(error)}`);
-  }
-}

package/core/module/FindPackageRoot.ts

@@ -1,58 +0,0 @@
-import path from "path";
-import fs from "fs";
-
-/**
- * 查找包含 package.json 的根目录
- * @param startPath 开始查找的路径
- * @returns 包含 package.json 的目录路径
- * @throws 如果输入路径无效
- */
-export function findPackageRoot(startPath: string): string {
-  // 验证输入路径
-  if (!startPath || typeof startPath !== "string") {
-    throw new Error("无效的起始路径：路径必须是非空字符串");
-  }
-
-  // 确保路径是绝对路径
-  let currentPath: string;
-  try {
-    currentPath = path.isAbsolute(startPath) ? startPath : path.resolve(startPath);
-  } catch (e) {
-    throw new Error(`无法解析路径：${startPath}`);
-  }
-
-  // 验证路径是否存在
-  try {
-    if (!fs.existsSync(currentPath)) {
-      throw new Error(`路径不存在：${currentPath}`);
-    }
-
-    // 如果是文件，从其父目录开始查找
-    const stat = fs.statSync(currentPath);
-    if (stat.isFile()) {
-      currentPath = path.dirname(currentPath);
-    }
-  } catch (e) {
-    throw new Error(`路径验证失败：${e instanceof Error ? e.message : String(e)}`);
-  }
-
-  // 向上查找 package.json
-  while (currentPath !== path.parse(currentPath).root) {
-    try {
-      const pkgJsonPath = path.join(currentPath, "package.json");
-      if (fs.existsSync(pkgJsonPath)) {
-        // 验证找到的 package.json 是否是文件
-        const pkgStat = fs.statSync(pkgJsonPath);
-        if (pkgStat.isFile()) {
-          return currentPath;
-        }
-      }
-    } catch (e) {
-      // 忽略单个路径的访问错误，继续向上查找
-    }
-    currentPath = path.dirname(currentPath);
-  }
-
-  // 如果没有找到 package.json，返回起始路径的父目录
-  return path.dirname(startPath);
-}

package/core/module/GetModulePath.ts

@@ -1,58 +0,0 @@
-import * as path from "path";
-
-/**
- * 获取当前模块的路径
- * @returns 当前模块的绝对路径
- * @throws 如果无法确定模块路径
- */
-export function getModulePath(): string {
-  // 从调用栈中提取调用者的路径
-  try {
-    const error = new Error();
-    if (error.stack) {
-      console.log("DEBUG STACK:", error.stack);
-      const stackLines = error.stack.split("\n");
-
-      // 跳过内部调用，找到真正的调用者
-      // 需要跳过：getModulePath, createModule, ts-node, node:internal
-      for (const line of stackLines) {
-        // 跳过内部函数和 Node.js/ts-node 的调用
-        if (!line.includes("at") ||
-            line.includes("getModulePath") ||
-            line.includes("createModule") ||
-            line.includes("CreateModule.ts") ||
-            line.includes("ts-node") ||
-            line.includes("node:internal")) {
-          continue;
-        }
-
-        // 提取文件路径
-        // 格式可能是：at xxx (/path/to/file.ts:1:2) 或 at /path/to/file.ts:1:2
-        const match = line.match(/\(([^:]+\.ts)/) || line.match(/at\s+([^:]+\.ts)/);
-        if (match && match[1]) {
-          const filePath = match[1];
-          console.log("提取到的路径:", filePath);
-          return path.resolve(filePath);
-        }
-      }
-    }
-  } catch (e) {
-    // 忽略提取 stack 时的错误
-  }
-
-  throw new Error("无法确定模块路径：当前环境不支持 __filename 且无法从调用栈中提取路径");
-}
-
-/**
- * 获取当前模块所在的目录
- * @returns 当前模块的目录路径
- * @throws 如果无法确定模块路径
- */
-export function getModuleDir(): string {
-  try {
-    const modulePath = getModulePath();
-    return path.dirname(modulePath);
-  } catch (error) {
-    throw new Error(`无法获取模块目录：${error instanceof Error ? error.message : String(error)}`);
-  }
-}

package/core/state.ts

@@ -1,72 +0,0 @@
-import express, { Express } from "express";
-import { LogLevel } from "../types";
-
-export interface MindBaseAppOptions {
-  /**
-   * 启动模式:
-   * - normal: 正常启动服务
-   * - sync: 同步数据库 Schema（仅收集）
-   * - migrate: 执行数据库迁移
-   * @default "normal"
-   */
-  mode?: "normal" | "sync" | "migrate";
-  /** 服务监听端口 @default 3000 */
-  port?: number;
-  /** 是否启用请求日志 @default true */
-  logging?: boolean;
-  /** 静态文件目录路径 */
-  staticPath?: string;
-  /** 是否解析 User-Agent 信息 @default true */
-  userAgent?: boolean;
-  /** 是否解析 IP 地理位置信息 @default true */
-  ip?: boolean;
-  /** 是否启用 CORS 跨域 @default true */
-  cors?: boolean;
-  /** API 路由前缀，如 "/api" */
-  apiPrefix?: string;
-  /**
-   * 日志级别（优先级从低到高）:
-   * - debug: 调试信息（显示所有）
-   * - info: 普通信息（隐藏 debug）
-   * - warn: 警告信息（隐藏 debug、info）
-   * - error: 错误信息（隐藏 debug、info、warn）
-   * - silent: 静默模式（隐藏所有）
-   * @default "info"
-   */
-  logLevel?: LogLevel;
-  /** 是否自动迁移数据库表结构 @default false */
-  autoMigrate?: boolean;
-  /** 数据库配置 */
-  database?: {
-    /** SQLite 数据库文件路径 @default "./data/app.db" */
-    path?: string;
-  };
-}
-export interface AppState {
-  options: MindBaseAppOptions;
-  express: Express;
-  db?: any; // Drizzle 数据库实例
-  schemas?: Record<string, any>; // 合并后的所有 schema
-}
-
-export function createState(options: MindBaseAppOptions = {}): AppState {
-  return {
-    options: {
-      mode: options.mode || (process.env.MIND_BASE_MODE as any) || "normal",
-      port: options.port || 3000,
-      logging: options.logging !== false,
-      staticPath: options.staticPath,
-      userAgent: options.userAgent !== false,
-      ip: options.ip !== false,
-      cors: options.cors !== false,
-      apiPrefix: options.apiPrefix,
-      logLevel: options.logLevel || "info",
-      autoMigrate: options.autoMigrate ?? false,
-      database: {
-        path: options.database?.path || "./data/app.db",
-      },
-    },
-    express: express(),
-    schemas: {},
-  };
-}

package/feature/cron/CronManager.ts

@@ -1,63 +0,0 @@
-import { CronJob } from "cron";
-import { randomUUID } from "crypto";
-
-interface CronConfig {
-  timezone?: string;
-}
-
-interface CronJobMap {
-  [id: string]: CronJob;
-}
-
-let jobs: CronJobMap = {};
-let config: CronConfig = {
-  timezone: "Asia/Shanghai",
-};
-
-export function setConfig(newConfig: CronConfig): void {
-  config = {
-    ...config,
-    ...newConfig,
-  };
-}
-
-export function addCron(pattern: string, handler: () => void | Promise<void>, customId?: string): string {
-  const id = customId || generateId();
-  if (jobs[id]) {
-    jobs[id].stop();
-  }
-  const job = new CronJob(pattern, handler, null, true, config.timezone);
-  jobs[id] = job;
-  return id;
-}
-
-export function stopCron(id: string): boolean {
-  const job = jobs[id];
-  if (job) {
-    job.stop();
-    delete jobs[id];
-    return true;
-  }
-  return false;
-}
-
-export function stopAllCron(): void {
-  Object.values(jobs).forEach((job) => {
-    job.stop();
-  });
-  jobs = {};
-}
-
-function generateId(): string {
-  return randomUUID();
-}
-
-const CronManager = {
-  setConfig,
-  addCron,
-  stopCron,
-  stopAllCron,
-};
-
-export default CronManager;
-export type { CronConfig };