imean-service-engine 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imean-service-engine",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "基于Hono的轻量级微服务引擎框架",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,7 +9,7 @@
     "dev": "tsx tests/integration/start-service.ts",
     "test": "vitest --run",
     "test:ui": "vitest --ui",
-    "test:coverage": "vitest --coverage",
+    "test:coverage": "vitest --run --coverage",
     "prepublishOnly": "npm run build && npm run test"
   },
   "keywords": [
@@ -18,6 +18,12 @@
     "framework",
     "typescript"
   ],
+  "files": [
+    "dist",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ],
   "author": "",
   "license": "MIT",
   "dependencies": {
@@ -32,6 +38,7 @@
   "devDependencies": {
     "@types/ejson": "^2.2.2",
     "@types/node": "^25.0.1",
+    "@vitest/coverage-v8": "4.0.15",
     "@vitest/ui": "^4.0.15",
     "imean-service-client": "^1.6.0",
     "tsup": "^8.5.1",

package/.vscode/settings.json

@@ -1,8 +0,0 @@
-{
-    "cSpell.words": [
-        "clazz",
-        "ejson",
-        "Htmx",
-        "imean"
-    ]
-}

package/src/core/checker.ts

@@ -1,33 +0,0 @@
-import logger from "./logger";
-
-export interface PreStartChecker {
-  name: string;
-  check: () => Promise<void> | void;
-  skip?: boolean;
-}
-
-export async function startCheck(
-  checkers: PreStartChecker[],
-  pass?: () => void | Promise<void>
-) {
-  logger.info("[ 预检开始 ]");
-
-  for (const [index, checker] of checkers.entries()) {
-    const seq = index + 1;
-    logger.info(`${seq}. ${checker.name}`);
-    try {
-      if (checker.skip) {
-        logger.warn(`${seq}. ${checker.name} [跳过]`);
-        continue;
-      }
-      await checker.check();
-      logger.info(`${seq}. ${checker.name} [成功]`);
-    } catch (error) {
-      logger.error(`${seq}. ${checker.name} [失败]`);
-      throw error;
-    }
-  }
-
-  logger.info("[ 预检完成 ]");
-  if (pass) await pass();
-}

package/src/core/decorators.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  Handler,
-  getAllHandlerMetadata,
-  getHandlerMetadata,
-} from "./decorators";
-
-describe("Handler装饰器", () => {
-  describe("Handler装饰器", () => {
-    it("应该能够标注方法为Handler", () => {
-      class TestService {
-        @Handler({ type: "route", options: { method: "GET" } })
-        getUser() {}
-      }
-
-      // 实例化类以确保装饰器的 addInitializer 执行
-      new TestService();
-
-      const metadata = getHandlerMetadata(TestService, "getUser");
-      expect(metadata).toHaveLength(1);
-      expect(metadata[0].type).toBe("route");
-      expect(metadata[0].options.method).toBe("GET");
-      expect(metadata[0].methodName).toBe("getUser");
-      expect(metadata[0].module).toBe(TestService);
-    });
-
-    it("应该支持多应用Handler装饰器", () => {
-      class TestService {
-        @Handler({ type: "route", options: { method: "GET" } })
-        @Handler({ type: "cache", options: { ttl: 60 } })
-        @Handler({ type: "rate-limit", options: { limit: 100 } })
-        getUser() {}
-      }
-
-      // 实例化类以确保装饰器的 addInitializer 执行
-      new TestService();
-
-      const metadata = getHandlerMetadata(TestService, "getUser");
-      expect(metadata).toHaveLength(3);
-
-      const routeMeta = metadata.find((m) => m.type === "route");
-      const cacheMeta = metadata.find((m) => m.type === "cache");
-      const rateLimitMeta = metadata.find((m) => m.type === "rate-limit");
-
-      expect(routeMeta).toBeDefined();
-      expect(cacheMeta).toBeDefined();
-      expect(rateLimitMeta).toBeDefined();
-      expect(routeMeta?.options.method).toBe("GET");
-      expect(cacheMeta?.options.ttl).toBe(60);
-      expect(rateLimitMeta?.options.limit).toBe(100);
-    });
-
-    it("应该能够获取所有Handler元数据", () => {
-      class TestService {
-        @Handler({ type: "route" })
-        getUser() {}
-
-        @Handler({ type: "route" })
-        createUser() {}
-
-        // 没有装饰器的方法不应该出现
-        deleteUser() {}
-      }
-
-      // 实例化类以确保装饰器的 addInitializer 执行
-      new TestService();
-
-      const allMetadata = getAllHandlerMetadata(TestService);
-      expect(allMetadata.size).toBe(2);
-      expect(allMetadata.has("getUser")).toBe(true);
-      expect(allMetadata.has("createUser")).toBe(true);
-      expect(allMetadata.has("deleteUser")).toBe(false);
-    });
-
-    it("Handler元数据应该包含完整信息", () => {
-      class TestService {
-        @Handler({ type: "route", options: { path: "/user" } })
-        getUser() {
-          return { id: 1 };
-        }
-      }
-
-      // 实例化类以确保装饰器的 addInitializer 执行
-      new TestService();
-
-      const metadata = getHandlerMetadata(TestService, "getUser");
-      expect(metadata[0]).toMatchObject({
-        type: "route",
-        options: { path: "/user" },
-        methodName: "getUser",
-        module: TestService,
-      });
-      expect(typeof metadata[0].method).toBe("function");
-    });
-  });
-});

package/src/core/decorators.ts

@@ -1,68 +0,0 @@
-import {
-  createMethodDecorator,
-  getAllMethodMetadata as getAllMetadata,
-} from "../metadata/metadata";
-import { HandlerMetadata } from "./types";
-
-/**
- * Handler装饰器元数据键
- */
-const HANDLER_METADATA_KEY = Symbol.for("imean:handlerMetadata");
-
-/**
- * 创建Handler装饰器（基于通用元数据工具）
- */
-const createHandlerDecorator = createMethodDecorator(HANDLER_METADATA_KEY);
-
-/**
- * 通用Handler装饰器（支持多应用）
- * 使用最新的 Stage 3 装饰器标准
- *
- * @param config Handler配置
- * @returns 方法装饰器
- */
-export function Handler<T = Record<string, any>>(config: {
-  type: string;
-  options?: T;
-}) {
-  return createHandlerDecorator({
-    type: config.type,
-    options: config.options || {},
-  });
-}
-
-/**
- * 获取方法的Handler元数据列表
- */
-export function getHandlerMetadata(
-  target: any,
-  methodName: string | symbol
-): HandlerMetadata[] {
-  const allMetadata = getAllMetadata(target, HANDLER_METADATA_KEY);
-  const metadataList = allMetadata.get(methodName) || [];
-  const prototype = target.prototype || target;
-
-  // 转换为HandlerMetadata格式，补充method和module信息
-  return metadataList.map((meta) => ({
-    ...meta,
-    method: prototype[methodName],
-    methodName: String(methodName),
-    module: prototype.constructor,
-  })) as HandlerMetadata[];
-}
-
-/**
- * 获取类的所有Handler元数据
- */
-export function getAllHandlerMetadata(
-  target: any
-): Map<string | symbol, HandlerMetadata[]> {
-  const allMetadata = getAllMetadata(target, HANDLER_METADATA_KEY);
-  const result = new Map<string | symbol, HandlerMetadata[]>();
-
-  for (const [methodName, metadataList] of allMetadata.entries()) {
-    result.set(methodName, metadataList as HandlerMetadata[]);
-  }
-
-  return result;
-}

package/src/core/engine.test.ts

@@ -1,218 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { Route, RoutePlugin } from "../plugins/route";
-import { Handler } from "./decorators";
-import { DuplicateModuleError } from "./errors";
-import { Testing } from "./testing";
-import { Plugin } from "./types";
-
-describe("MicroserviceEngine", () => {
-  let engine: ReturnType<typeof Testing.createTestEngine>["engine"];
-  let Module: ReturnType<typeof Testing.createTestEngine>["Module"];
-
-  beforeEach(() => {
-    // 每个测试都会创建新的 Factory，使用不同的 key，自动隔离
-    const testEngine = Testing.createTestEngine({ plugins: [] });
-    engine = testEngine.engine;
-    Module = testEngine.Module;
-  });
-
-  describe("Module装饰器", () => {
-    it("应该能够使用Module装饰器装饰类", () => {
-      @Module("test-module")
-      class TestService {}
-
-      const modules = engine.getModules();
-      expect(modules).toHaveLength(1);
-      expect(modules[0].name).toBe("test-module");
-      expect(modules[0].clazz).toBe(TestService);
-    });
-
-    it("应该防止重复注册同名模块", () => {
-      @Module("test-module")
-      class TestService1 {}
-
-      @Module("test-module")
-      class TestService2 {}
-
-      // 错误会在引擎加载模块时抛出（调用 getModules 或 start）
-      expect(() => {
-        engine.getModules();
-      }).toThrow(DuplicateModuleError);
-    });
-
-    it("应该支持模块配置", () => {
-      @Module("test-module", {
-        routePrefix: "/api",
-      })
-      class TestService {}
-
-      const modules = engine.getModules();
-      expect(modules[0].options.routePrefix).toBe("/api");
-    });
-  });
-
-  describe("引擎启动", () => {
-    it("应该能够启动引擎", async () => {
-      const plugin: Plugin = {
-        name: "test-plugin",
-        onInit: vi.fn(),
-        onModuleLoad: vi.fn(),
-        onHandlerLoad: vi.fn(),
-        onBeforeStart: vi.fn(),
-        onAfterStart: vi.fn(),
-      };
-
-      // 使用 Testing 创建带插件的引擎
-      const { engine: testEngine, Module: TestModule } =
-        Testing.createTestEngine({
-          plugins: [plugin],
-        });
-
-      @TestModule("test-module")
-      class TestService {
-        @Handler({ type: "test" })
-        getUser() {}
-      }
-
-      await testEngine.start();
-
-      expect(plugin.onInit).toHaveBeenCalled();
-      expect(plugin.onModuleLoad).toHaveBeenCalled();
-      expect(plugin.onHandlerLoad).toHaveBeenCalled();
-      expect(plugin.onBeforeStart).toHaveBeenCalled();
-      expect(plugin.onAfterStart).toHaveBeenCalled();
-
-      await testEngine.stop();
-    });
-
-    it("应该防止重复启动", async () => {
-      await engine.start();
-
-      await expect(engine.start()).rejects.toThrow("already started");
-    });
-
-    it("应该能够停止引擎", async () => {
-      const plugin: Plugin = {
-        name: "test-plugin",
-        onDestroy: vi.fn(),
-      };
-
-      const { engine: testEngine } = Testing.createTestEngine({
-        plugins: [plugin],
-      });
-
-      await testEngine.start();
-      await testEngine.stop();
-
-      expect(plugin.onDestroy).toHaveBeenCalled();
-    });
-  });
-
-  describe("模块实例管理", () => {
-    it("应该能够获取模块实例（单例）", () => {
-      @Module("test-module")
-      class TestService {}
-
-      const instance1 = engine.get(TestService);
-      const instance2 = engine.get(TestService);
-
-      expect(instance1).toBe(instance2); // 应该是同一个实例
-    });
-  });
-
-  describe("配置管理", () => {
-    it("应该能够获取引擎配置", () => {
-      expect(engine.options.name).toBe("test-service");
-      expect(engine.options.version).toBe("1.0.0");
-      expect(engine.options.hostname).toBe("0.0.0.0");
-    });
-
-    it("应该使用默认配置", () => {
-      const { engine: defaultEngine } = Testing.createTestEngine({
-        plugins: [],
-        options: {
-          name: "default-service",
-          version: "1.0.0",
-        },
-      });
-
-      expect(defaultEngine.options.hostname).toBe("0.0.0.0");
-    });
-
-    it("配置应该是冻结的，无法修改", () => {
-      expect(() => {
-        (engine.options as any).name = "modified";
-      }).toThrow();
-    });
-
-    it("应该能够获取实际使用的端口", async () => {
-      const port = await engine.start();
-      expect(port).toBeGreaterThanOrEqual(3000);
-      expect(engine.getPort()).toBe(port);
-      await engine.stop();
-    });
-  });
-
-  describe("版本路由", () => {
-    it("应该自动注册版本路由", async () => {
-      const port = await engine.start();
-      const response = await fetch(`http://127.0.0.1:${port}`);
-      expect(response.ok).toBe(true);
-      const data = await response.json();
-      expect(data).toEqual({
-        name: "test-service",
-        version: "1.0.0",
-        status: "running",
-      });
-      await engine.stop();
-    });
-
-    it("应该支持引擎 prefix", async () => {
-      const { engine: testEngine } = Testing.createTestEngine({
-        plugins: [],
-        options: {
-          name: "test-service",
-          version: "1.0.0",
-          prefix: "/api",
-        },
-      });
-
-      const port = await testEngine.start();
-      const response = await fetch(`http://127.0.0.1:${port}/api`);
-      expect(response.ok).toBe(true);
-      const data = await response.json();
-      expect(data).toEqual({
-        name: "test-service",
-        version: "1.0.0",
-        status: "running",
-      });
-      await testEngine.stop();
-    });
-
-    it("如果用户已注册版本路由，应该跳过注册", async () => {
-      const { engine: testEngine, Module: TestModule } =
-        Testing.createTestEngine({
-          plugins: [new RoutePlugin()],
-        });
-
-      @TestModule("test-module")
-      class TestService {
-        @Route({
-          method: "GET",
-          path: "/version",
-        })
-        getVersion() {
-          return { custom: "version" };
-        }
-      }
-
-      const port = await testEngine.start();
-      const response = await fetch(`http://127.0.0.1:${port}/version`);
-      expect(response.ok).toBe(true);
-      // 应该返回用户自定义的版本路由，而不是引擎的版本路由
-      const data = await response.json();
-      expect(data).toEqual({ custom: "version" });
-      await testEngine.stop();
-    });
-  });
-});